9362a10
ZhenYi
refactor: remove OAuth-related modules and update references for identity service integration
9362a10
/**
* Generated by orval 🍺
* Do not edit manually.
* auth
* 认证与账号服务：工作量证明、口令与验证码登录、二次验证、注册、口令重置、访问令牌与 SSH 公钥。
* OpenAPI spec version: 1.0.0
*/
import type {
AccessTokenCreateRequest,
AddMemberBody,
AppTokenRequest,
AssignRoleBody,
AuthAccessTokenListParams,
AuthOrganizationBanListParams,
AuthOrganizationDeleteParams,
AuthOrganizationInviteListParams,
AuthOrganizationMemberListParams,
AuthOrganizationMemberRemoveParams,
AuthSshKeyListParams,
BanMemberBody,
CheckPermissionBody,
CreateInviteBody,
CreateOrganizationBody,
CreateRoleBody,
EnvelopeAccessTokenCreateResponse,
EnvelopeAppTokenResponse,
EnvelopeBool,
EnvelopeChallengeResponse,
EnvelopeCreateInviteResponse,
EnvelopeHealthResponse,
EnvelopeLoginCodeResponse,
EnvelopeLogoutResponse,
EnvelopeMeResponse,
EnvelopeMemberSummary,
EnvelopeNoData,
EnvelopeOrganizationSummary,
EnvelopePasswordResetConfirmResponse,
EnvelopePasswordResetResponse,
EnvelopePermissionCheck,
EnvelopeReadinessResponse,
EnvelopeRedeemInviteResponse,
EnvelopeRegisterCodeResponse,
EnvelopeRoleSummary,
EnvelopeSshKeySummary,
EnvelopeTokenResponse,
EnvelopeUserLoginResponse,
EnvelopeUserRegisterResponse,
EnvelopeVecAccessTokenSummary,
EnvelopeVecInviteSummary,
EnvelopeVecMemberSummary,
EnvelopeVecOrganizationSummary,
EnvelopeVecRoleSummary,
EnvelopeVecSshKeySummary,
EnvelopeVecString,
LoginCodeRequest,
LoginCodeVerifyRequest,
LoginVerifyRequest,
PasswordResetConfirmRequest,
PasswordResetRequest,
ReasonBody,
RedeemInviteBody,
RegisterCodeRequest,
SetMemberRoleBody,
SetRolePermissionsBody,
SshKeyAddRequest,
TokenRequest,
TransferBody,
UpdateBanBody,
UpdateMemberBody,
UpdateOrganizationBody,
UpdateRoleBody,
UserLoginRequest,
UserRegisterRequest,
} from "./auth.schemas";
import { authClient } from "../../lib/jwtmanager/http";
export type authAccessTokenListResponse200 = {
data: EnvelopeVecAccessTokenSummary;
status: 200;
};
export type authAccessTokenListResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authAccessTokenListResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authAccessTokenListResponseSuccess =
authAccessTokenListResponse200 & {
headers: Headers;
};
export type authAccessTokenListResponseError = (
authAccessTokenListResponse401 | authAccessTokenListResponse500
) & {
headers: Headers;
};
export type authAccessTokenListResponse =
authAccessTokenListResponseSuccess | authAccessTokenListResponseError;
export const getAuthAccessTokenListUrl = (
params?: AuthAccessTokenListParams,
) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : String(value));
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/oauth/access-tokens?${stringifiedParams}`
: `/api/v1/oauth/access-tokens`;
};
/**
* 按创建时间倒序返回当前账号的令牌摘要，只给指纹与状态，不回吐令牌原文。分页参数由 `page` / `page_size` 控制。查询串不是合法分页参数或路径/方法不匹配时返回 400 / 404 由 actix-web 直接给出。
* @summary 列示访问令牌
*/
export const authAccessTokenList = async (
params?: AuthAccessTokenListParams,
options?: Parameters<typeof authClient>[1],
): Promise<authAccessTokenListResponse> => {
return authClient<authAccessTokenListResponse>(
getAuthAccessTokenListUrl(params),
{
...options,
method: "GET",
},
);
};
export type authAccessTokenCreateResponse200 = {
data: EnvelopeAccessTokenCreateResponse;
status: 200;
};
export type authAccessTokenCreateResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authAccessTokenCreateResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authAccessTokenCreateResponse429 = {
data: EnvelopeNoData;
status: 429;
};
export type authAccessTokenCreateResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authAccessTokenCreateResponseSuccess =
authAccessTokenCreateResponse200 & {
headers: Headers;
};
export type authAccessTokenCreateResponseError = (
| authAccessTokenCreateResponse400
| authAccessTokenCreateResponse401
| authAccessTokenCreateResponse429
| authAccessTokenCreateResponse500
) & {
headers: Headers;
};
export type authAccessTokenCreateResponse =
authAccessTokenCreateResponseSuccess | authAccessTokenCreateResponseError;
export const getAuthAccessTokenCreateUrl = () => {
return `/api/v1/oauth/access-tokens`;
};
/**
* 名称 1~64 字符、备注最长 255 字符，`scope` 必须全部命中白名单（最多 32 项），`expires_in_secs` 取值 60 ~ 31536000（不填表示长期有效）。同一账号未吊销的令牌上限 50 个。签发成功记 `AccessKeyAdded` 审计事件。
* @summary 签发访问令牌
*/
export const authAccessTokenCreate = async (
accessTokenCreateRequest: AccessTokenCreateRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authAccessTokenCreateResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authAccessTokenCreateResponse>(
getAuthAccessTokenCreateUrl(),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(accessTokenCreateRequest),
},
);
};
export type authAccessTokenRevokeResponse200 = {
data: EnvelopeNoData;
status: 200;
};
export type authAccessTokenRevokeResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authAccessTokenRevokeResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authAccessTokenRevokeResponseSuccess =
authAccessTokenRevokeResponse200 & {
headers: Headers;
};
export type authAccessTokenRevokeResponseError = (
authAccessTokenRevokeResponse401 | authAccessTokenRevokeResponse500
) & {
headers: Headers;
};
export type authAccessTokenRevokeResponse =
authAccessTokenRevokeResponseSuccess | authAccessTokenRevokeResponseError;
export const getAuthAccessTokenRevokeUrl = (tokenId: string) => {
return `/api/v1/oauth/access-tokens/${tokenId}`;
};
/**
* 把令牌标记为已吊销，记录保留不硬删；重复调用幂等。令牌不存在或不属于当前账号返回 `access_token_not_found`（按 `errors.rs` 的归类为 401）。吊销成功记 `AccessKeyRemoved` 审计事件。
* @summary 吊销访问令牌
*/
export const authAccessTokenRevoke = async (
tokenId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authAccessTokenRevokeResponse> => {
return authClient<authAccessTokenRevokeResponse>(
getAuthAccessTokenRevokeUrl(tokenId),
{
...options,
method: "DELETE",
},
);
};
export type authAppTokenIssueResponse200 = {
data: EnvelopeAppTokenResponse;
status: 200;
};
export type authAppTokenIssueResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authAppTokenIssueResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authAppTokenIssueResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authAppTokenIssueResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authAppTokenIssueResponse503 = {
data: EnvelopeNoData;
status: 503;
};
export type authAppTokenIssueResponseSuccess = authAppTokenIssueResponse200 & {
headers: Headers;
};
export type authAppTokenIssueResponseError = (
| authAppTokenIssueResponse400
| authAppTokenIssueResponse401
| authAppTokenIssueResponse404
| authAppTokenIssueResponse500
| authAppTokenIssueResponse503
) & {
headers: Headers;
};
export type authAppTokenIssueResponse =
authAppTokenIssueResponseSuccess | authAppTokenIssueResponseError;
export const getAuthAppTokenIssueUrl = () => {
return `/api/v1/oauth/app-tokens`;
};
/**
* 认证中心用 Ed25519 私钥签发 JWT（`alg=EdDSA`），`aud` 为目标 app 的 audience，`client_id` 为 app 标识。服务通过内部 gRPC authority 验签。`ttl_seconds` 取值 1 ~ 3600，不填或填 0 用默认 900。会话未绑定账号返回 `unauthenticated`（401）；app 未在 `apps` 清单里返回 `app_not_found`（404）；私钥未配置返回 `unavailable`（503）。
* @summary 签发内部应用令牌
*/
export const authAppTokenIssue = async (
appTokenRequest: AppTokenRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authAppTokenIssueResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authAppTokenIssueResponse>(getAuthAppTokenIssueUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(appTokenRequest),
});
};
export type authChallengeResponse200 = {
data: EnvelopeChallengeResponse;
status: 200;
};
export type authChallengeResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authChallengeResponseSuccess = authChallengeResponse200 & {
headers: Headers;
};
export type authChallengeResponseError = authChallengeResponse500 & {
headers: Headers;
};
export type authChallengeResponse =
authChallengeResponseSuccess | authChallengeResponseError;
export const getAuthChallengeUrl = () => {
return `/api/v1/oauth/challenge`;
};
/**
* 把挑战写进当前会话并返回。客户端需要为 `context` 找出一枚满足 `difficulty`（前导零比特数）的 nonce；`pow.v1` 算法与前端求解器一致。
* @summary 签发工作量证明挑战
*/
export const authChallenge = async (
options?: Parameters<typeof authClient>[1],
): Promise<authChallengeResponse> => {
return authClient<authChallengeResponse>(getAuthChallengeUrl(), {
...options,
method: "POST",
});
};
export type authLoginResponse200 = {
data: EnvelopeUserLoginResponse;
status: 200;
};
export type authLoginResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authLoginResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authLoginResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authLoginResponse429 = {
data: EnvelopeNoData;
status: 429;
};
export type authLoginResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authLoginResponseSuccess = authLoginResponse200 & {
headers: Headers;
};
export type authLoginResponseError = (
| authLoginResponse400
| authLoginResponse401
| authLoginResponse403
| authLoginResponse429
| authLoginResponse500
) & {
headers: Headers;
};
export type authLoginResponse =
authLoginResponseSuccess | authLoginResponseError;
export const getAuthLoginUrl = () => {
return `/api/v1/oauth/login`;
};
/**
* 用口令登录。`identity` 可以是用户名、邮箱（大小写不敏感）或用户编号，`password_hash` 是客户端先算好的口令摘要，工作量证明的载荷必须是 `identity`。账号启用了多因子时返回 `mfa_required: true` 与 `challenge`，此时会话尚未绑定，需再调 `/api/v1/oauth/login/verify`。
* @summary 口令登录
*/
export const authLogin = async (
userLoginRequest: UserLoginRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authLoginResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authLoginResponse>(getAuthLoginUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(userLoginRequest),
});
};
export type authLoginCodeResponse200 = {
data: EnvelopeLoginCodeResponse;
status: 200;
};
export type authLoginCodeResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authLoginCodeResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authLoginCodeResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authLoginCodeResponse429 = {
data: EnvelopeNoData;
status: 429;
};
export type authLoginCodeResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authLoginCodeResponseSuccess = authLoginCodeResponse200 & {
headers: Headers;
};
export type authLoginCodeResponseError = (
| authLoginCodeResponse400
| authLoginCodeResponse401
| authLoginCodeResponse403
| authLoginCodeResponse429
| authLoginCodeResponse500
) & {
headers: Headers;
};
export type authLoginCodeResponse =
authLoginCodeResponseSuccess | authLoginCodeResponseError;
export const getAuthLoginCodeUrl = () => {
return `/api/v1/oauth/login/code`;
};
/**
* 向账号邮箱发送 6 位登录验证码，`expires_in_secs` 为有效期。工作量证明的载荷必须是 `email`。同一账号的发码间隔受 `email_code_rate_limit_secs` 限制。
* @summary 发送邮箱登录验证码
*/
export const authLoginCode = async (
loginCodeRequest: LoginCodeRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authLoginCodeResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authLoginCodeResponse>(getAuthLoginCodeUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(loginCodeRequest),
});
};
export type authLoginCodeVerifyResponse200 = {
data: EnvelopeUserLoginResponse;
status: 200;
};
export type authLoginCodeVerifyResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authLoginCodeVerifyResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authLoginCodeVerifyResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authLoginCodeVerifyResponse429 = {
data: EnvelopeNoData;
status: 429;
};
export type authLoginCodeVerifyResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authLoginCodeVerifyResponseSuccess =
authLoginCodeVerifyResponse200 & {
headers: Headers;
};
export type authLoginCodeVerifyResponseError = (
| authLoginCodeVerifyResponse400
| authLoginCodeVerifyResponse401
| authLoginCodeVerifyResponse403
| authLoginCodeVerifyResponse429
| authLoginCodeVerifyResponse500
) & {
headers: Headers;
};
export type authLoginCodeVerifyResponse =
authLoginCodeVerifyResponseSuccess | authLoginCodeVerifyResponseError;
export const getAuthLoginCodeVerifyUrl = () => {
return `/api/v1/oauth/login/code/verify`;
};
/**
* 用邮箱登录验证码换会话。工作量证明的载荷必须是 `email`。验证码一旦核对通过即作废，连续输错 `max_verify_attempts` 次后需重新申请。账号启用了多因子时返回 `mfa_required: true` 与 `challenge`。
* @summary 邮箱验证码换会话
*/
export const authLoginCodeVerify = async (
loginCodeVerifyRequest: LoginCodeVerifyRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authLoginCodeVerifyResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authLoginCodeVerifyResponse>(getAuthLoginCodeVerifyUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(loginCodeVerifyRequest),
});
};
export type authLoginVerifyResponse200 = {
data: EnvelopeUserLoginResponse;
status: 200;
};
export type authLoginVerifyResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authLoginVerifyResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authLoginVerifyResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authLoginVerifyResponse429 = {
data: EnvelopeNoData;
status: 429;
};
export type authLoginVerifyResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authLoginVerifyResponseSuccess = authLoginVerifyResponse200 & {
headers: Headers;
};
export type authLoginVerifyResponseError = (
| authLoginVerifyResponse400
| authLoginVerifyResponse401
| authLoginVerifyResponse403
| authLoginVerifyResponse429
| authLoginVerifyResponse500
) & {
headers: Headers;
};
export type authLoginVerifyResponse =
authLoginVerifyResponseSuccess | authLoginVerifyResponseError;
export const getAuthLoginVerifyUrl = () => {
return `/api/v1/oauth/login/verify`;
};
/**
* 用 6 位 TOTP 动态码或一枚未使用的恢复码完成二次验证并绑定会话。`challenge` 必须与 `/api/v1/oauth/login` 或 `/api/v1/oauth/login/code/verify` 返回的一致，挑战有效期 300 秒，同一动态码时间步不能重复使用，恢复码用掉即作废。
* @summary 二次验证换会话
*/
export const authLoginVerify = async (
loginVerifyRequest: LoginVerifyRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authLoginVerifyResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authLoginVerifyResponse>(getAuthLoginVerifyUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(loginVerifyRequest),
});
};
export type authMeResponse200 = {
data: EnvelopeMeResponse;
status: 200;
};
export type authMeResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authMeResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authMeResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authMeResponseSuccess = authMeResponse200 & {
headers: Headers;
};
export type authMeResponseError = (
authMeResponse401 | authMeResponse403 | authMeResponse500
) & {
headers: Headers;
};
export type authMeResponse = authMeResponseSuccess | authMeResponseError;
export const getAuthMeUrl = () => {
return `/api/v1/oauth/me`;
};
/**
* 通过会话 Cookie 或 Bearer 访问令牌返回用户自述信息，含头像地址。Bearer 令牌需具备 profile、email、avatar 权限，并校验账号与会话状态。结果在服务端缓存 300 秒，每第 5 次访问回源刷新；登出与改密会主动失效该缓存。
* @summary 当前登录用户
*/
export const authMe = async (
options?: Parameters<typeof authClient>[1],
): Promise<authMeResponse> => {
return authClient<authMeResponse>(getAuthMeUrl(), {
...options,
method: "GET",
});
};
export type authPasswordResetRequestResponse200 = {
data: EnvelopePasswordResetResponse;
status: 200;
};
export type authPasswordResetRequestResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authPasswordResetRequestResponse429 = {
data: EnvelopeNoData;
status: 429;
};
export type authPasswordResetRequestResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authPasswordResetRequestResponseSuccess =
authPasswordResetRequestResponse200 & {
headers: Headers;
};
export type authPasswordResetRequestResponseError = (
| authPasswordResetRequestResponse400
| authPasswordResetRequestResponse429
| authPasswordResetRequestResponse500
) & {
headers: Headers;
};
export type authPasswordResetRequestResponse =
| authPasswordResetRequestResponseSuccess
| authPasswordResetRequestResponseError;
export const getAuthPasswordResetRequestUrl = () => {
return `/api/v1/oauth/password/reset`;
};
/**
* 校验工作量证明（payload = 邮箱的 UTF-8 字节）后，作废该用户其余未消费的重置令牌，签发新令牌（长度 `reset_token_bytes`，有效期 `reset_token_ttl_secs`），库内只存 `sha256_hex(token)` 且 `hash_key_id = "sha256-v1"`，同时把摘要写入缓存键 `auth:code:reset:{email}`，发信限流键 `auth:rate:reset:{email}`。
* @summary 申请密码重置
*/
export const authPasswordResetRequest = async (
passwordResetRequest: PasswordResetRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authPasswordResetRequestResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authPasswordResetRequestResponse>(
getAuthPasswordResetRequestUrl(),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(passwordResetRequest),
},
);
};
export type authPasswordResetResponse200 = {
data: EnvelopePasswordResetConfirmResponse;
status: 200;
};
export type authPasswordResetResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authPasswordResetResponse429 = {
data: EnvelopeNoData;
status: 429;
};
export type authPasswordResetResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authPasswordResetResponseSuccess = authPasswordResetResponse200 & {
headers: Headers;
};
export type authPasswordResetResponseError = (
| authPasswordResetResponse400
| authPasswordResetResponse429
| authPasswordResetResponse500
) & {
headers: Headers;
};
export type authPasswordResetResponse =
authPasswordResetResponseSuccess | authPasswordResetResponseError;
export const getAuthPasswordResetUrl = () => {
return `/api/v1/oauth/password/reset/confirm`;
};
/**
* 校验工作量证明（payload = `token` 的 UTF-8 字节）与缓存键 `auth:code:reset:{email}`（尝试上限 `max_verify_attempts`，错误计入 `invalid_email_code`）后，条件消费数据库令牌行（`consumed_at` 单次占用），Argon2 重哈希新口令，更新 `password_hash`/`password_updated_at`/`password_must_change`/`security_version + 1`，作废其余令牌并记 `PasswordChange` 审计事件。
* @summary 确认密码重置
*/
export const authPasswordReset = async (
passwordResetConfirmRequest: PasswordResetConfirmRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authPasswordResetResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authPasswordResetResponse>(getAuthPasswordResetUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(passwordResetConfirmRequest),
});
};
export type authRegisterResponse200 = {
data: EnvelopeUserRegisterResponse;
status: 200;
};
export type authRegisterResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authRegisterResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authRegisterResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authRegisterResponse429 = {
data: EnvelopeNoData;
status: 429;
};
export type authRegisterResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authRegisterResponseSuccess = authRegisterResponse200 & {
headers: Headers;
};
export type authRegisterResponseError = (
| authRegisterResponse400
| authRegisterResponse403
| authRegisterResponse409
| authRegisterResponse429
| authRegisterResponse500
) & {
headers: Headers;
};
export type authRegisterResponse =
authRegisterResponseSuccess | authRegisterResponseError;
export const getAuthRegisterUrl = () => {
return `/api/v1/oauth/register`;
};
/**
* 校验工作量证明（payload = 用户名的 UTF-8 字节）、用户名/展示名/出生日期/邮箱、邮箱验证码（键 `auth:code:register:{email}`，尝试上限 `max_verify_attempts`）后，Argon2 重哈希口令并创建用户与初始档案。成功后写会话（user_id、security_version、renew）并记审计事件。
* @summary 提交注册
*/
export const authRegister = async (
userRegisterRequest: UserRegisterRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authRegisterResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authRegisterResponse>(getAuthRegisterUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(userRegisterRequest),
});
};
export type authRegisterCodeResponse200 = {
data: EnvelopeRegisterCodeResponse;
status: 200;
};
export type authRegisterCodeResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authRegisterCodeResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authRegisterCodeResponse429 = {
data: EnvelopeNoData;
status: 429;
};
export type authRegisterCodeResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authRegisterCodeResponseSuccess = authRegisterCodeResponse200 & {
headers: Headers;
};
export type authRegisterCodeResponseError = (
| authRegisterCodeResponse400
| authRegisterCodeResponse409
| authRegisterCodeResponse429
| authRegisterCodeResponse500
) & {
headers: Headers;
};
export type authRegisterCodeResponse =
authRegisterCodeResponseSuccess | authRegisterCodeResponseError;
export const getAuthRegisterCodeUrl = () => {
return `/api/v1/oauth/register/code`;
};
/**
* 校验工作量证明（payload = 邮箱的 UTF-8 字节）与邮箱格式后，把 6 位验证码写入缓存并寄出。缓存键 `auth:code:register:{email}`，有效期由 `verify_code_ttl_secs` 决定，发码限流键 `auth:rate:register:{email}`。
* @summary 发送注册验证码
*/
export const authRegisterCode = async (
registerCodeRequest: RegisterCodeRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authRegisterCodeResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authRegisterCodeResponse>(getAuthRegisterCodeUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(registerCodeRequest),
});
};
export type authLogoutResponse200 = {
data: EnvelopeLogoutResponse;
status: 200;
};
export type authLogoutResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authLogoutResponseSuccess = authLogoutResponse200 & {
headers: Headers;
};
export type authLogoutResponseError = authLogoutResponse500 & {
headers: Headers;
};
export type authLogoutResponse =
authLogoutResponseSuccess | authLogoutResponseError;
export const getAuthLogoutUrl = () => {
return `/api/v1/oauth/session/logout`;
};
/**
* 销毁当前会话，并清掉该用户的 `/api/v1/oauth/me` 缓存。匿名调用同样成功，此时 `user_id` 为 `null`。
* @summary 登出
*/
export const authLogout = async (
options?: Parameters<typeof authClient>[1],
): Promise<authLogoutResponse> => {
return authClient<authLogoutResponse>(getAuthLogoutUrl(), {
...options,
method: "POST",
});
};
export type authTokenIssueResponse200 = {
data: EnvelopeTokenResponse;
status: 200;
};
export type authTokenIssueResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authTokenIssueResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authTokenIssueResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authTokenIssueResponseSuccess = authTokenIssueResponse200 & {
headers: Headers;
};
export type authTokenIssueResponseError = (
| authTokenIssueResponse400
| authTokenIssueResponse401
| authTokenIssueResponse404
) & {
headers: Headers;
};
export type authTokenIssueResponse =
authTokenIssueResponseSuccess | authTokenIssueResponseError;
export const getAuthTokenIssueUrl = () => {
return `/api/v1/oauth/session/token`;
};
/**
* 认证中心用 Ed25519 私钥签发 JWT（`alg=EdDSA`），`aud` 固定为 `gitdata.ai`，`azp`（`app_id`）可选。服务通过内部 gRPC authority 验签。`ttl_seconds` 取值 1 ~ 3600，不填或填 0 用默认 900。
* @summary 用会话换取平台访问令牌
*/
export const authTokenIssue = async (
tokenRequest: TokenRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authTokenIssueResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authTokenIssueResponse>(getAuthTokenIssueUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(tokenRequest),
});
};
export type authSshKeyListResponse200 = {
data: EnvelopeVecSshKeySummary;
status: 200;
};
export type authSshKeyListResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authSshKeyListResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authSshKeyListResponseSuccess = authSshKeyListResponse200 & {
headers: Headers;
};
export type authSshKeyListResponseError = (
authSshKeyListResponse401 | authSshKeyListResponse500
) & {
headers: Headers;
};
export type authSshKeyListResponse =
authSshKeyListResponseSuccess | authSshKeyListResponseError;
export const getAuthSshKeyListUrl = (params?: AuthSshKeyListParams) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : String(value));
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/oauth/ssh-keys?${stringifiedParams}`
: `/api/v1/oauth/ssh-keys`;
};
/**
* 按创建时间倒序返回当前账号的公钥，含已吊销与已过期的记录。分页参数由 `page` / `page_size` 控制。查询串不是合法分页参数时由 actix-web 直接返回 400。
* @summary 列示 SSH 公钥
*/
export const authSshKeyList = async (
params?: AuthSshKeyListParams,
options?: Parameters<typeof authClient>[1],
): Promise<authSshKeyListResponse> => {
return authClient<authSshKeyListResponse>(getAuthSshKeyListUrl(params), {
...options,
method: "GET",
});
};
export type authSshKeyAddResponse200 = {
data: EnvelopeSshKeySummary;
status: 200;
};
export type authSshKeyAddResponse400 = {
data: EnvelopeNoData;
status: 400;
};
export type authSshKeyAddResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authSshKeyAddResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authSshKeyAddResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authSshKeyAddResponseSuccess = authSshKeyAddResponse200 & {
headers: Headers;
};
export type authSshKeyAddResponseError = (
| authSshKeyAddResponse400
| authSshKeyAddResponse401
| authSshKeyAddResponse409
| authSshKeyAddResponse500
) & {
headers: Headers;
};
export type authSshKeyAddResponse =
authSshKeyAddResponseSuccess | authSshKeyAddResponseError;
export const getAuthSshKeyAddUrl = () => {
return `/api/v1/oauth/ssh-keys`;
};
/**
* 名称 1~64 字符、备注最长 255 字符，公钥 32~8192 字节且必须是受支持的单行 OpenSSH 公钥，`expires_at` 必须晚于当前时间。重复公钥（指纹唯一）返回 `ssh_key_taken`。添加成功记 `PublicKeyAdded` 审计事件。
* @summary 添加 SSH 公钥
*/
export const authSshKeyAdd = async (
sshKeyAddRequest: SshKeyAddRequest,
options?: Parameters<typeof authClient>[1],
): Promise<authSshKeyAddResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authSshKeyAddResponse>(getAuthSshKeyAddUrl(), {
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(sshKeyAddRequest),
});
};
export type authSshKeyDeleteResponse200 = {
data: EnvelopeNoData;
status: 200;
};
export type authSshKeyDeleteResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authSshKeyDeleteResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authSshKeyDeleteResponse500 = {
data: EnvelopeNoData;
status: 500;
};
export type authSshKeyDeleteResponseSuccess = authSshKeyDeleteResponse200 & {
headers: Headers;
};
export type authSshKeyDeleteResponseError = (
| authSshKeyDeleteResponse401
| authSshKeyDeleteResponse404
| authSshKeyDeleteResponse500
) & {
headers: Headers;
};
export type authSshKeyDeleteResponse =
authSshKeyDeleteResponseSuccess | authSshKeyDeleteResponseError;
export const getAuthSshKeyDeleteUrl = (keyId: string) => {
return `/api/v1/oauth/ssh-keys/${keyId}`;
};
/**
* 把公钥标记为已吊销，记录保留不硬删；重复调用幂等。公钥不存在或不属于当前账号返回 `ssh_key_not_found`。吊销成功记 `PublicKeyRemoved` 审计事件，并递增 `security_version` 让该账号既有的访问令牌一并失效。`key_id` 不是合法 UUID 时由 actix-web 的路径提取器直接返回 400。
* @summary 吊销 SSH 公钥
*/
export const authSshKeyDelete = async (
keyId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authSshKeyDeleteResponse> => {
return authClient<authSshKeyDeleteResponse>(getAuthSshKeyDeleteUrl(keyId), {
...options,
method: "DELETE",
});
};
export type authOrganizationListResponse200 = {
data: EnvelopeVecOrganizationSummary;
status: 200;
};
export type authOrganizationListResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authOrganizationListResponseSuccess =
authOrganizationListResponse200 & {
headers: Headers;
};
export type authOrganizationListResponseError =
authOrganizationListResponse401 & {
headers: Headers;
};
export type authOrganizationListResponse =
authOrganizationListResponseSuccess | authOrganizationListResponseError;
export const getAuthOrganizationListUrl = () => {
return `/api/v1/organizations`;
};
/**
* 默认只返回 ACTIVE 组织；`include_archived=true` 时一并返回已归档组织。
* @summary 列示我加入的组织
*/
export const authOrganizationList = async (
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationListResponse> => {
return authClient<authOrganizationListResponse>(
getAuthOrganizationListUrl(),
{
...options,
method: "GET",
},
);
};
export type authOrganizationCreateResponse200 = {
data: EnvelopeOrganizationSummary;
status: 200;
};
export type authOrganizationCreateResponse401 = {
data: EnvelopeNoData;
status: 401;
};
export type authOrganizationCreateResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationCreateResponseSuccess =
authOrganizationCreateResponse200 & {
headers: Headers;
};
export type authOrganizationCreateResponseError = (
authOrganizationCreateResponse401 | authOrganizationCreateResponse409
) & {
headers: Headers;
};
export type authOrganizationCreateResponse =
authOrganizationCreateResponseSuccess | authOrganizationCreateResponseError;
export const getAuthOrganizationCreateUrl = () => {
return `/api/v1/organizations`;
};
/**
* 创建者自动成为 OWNER 并写入 owner/admin/member 三个内置角色。slug 全局唯一且只允许小写字母、数字与连字符。
* @summary 新建组织
*/
export const authOrganizationCreate = async (
createOrganizationBody: CreateOrganizationBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationCreateResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationCreateResponse>(
getAuthOrganizationCreateUrl(),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(createOrganizationBody),
},
);
};
export type authOrganizationInviteRedeemResponse200 = {
data: EnvelopeRedeemInviteResponse;
status: 200;
};
export type authOrganizationInviteRedeemResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationInviteRedeemResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationInviteRedeemResponseSuccess =
authOrganizationInviteRedeemResponse200 & {
headers: Headers;
};
export type authOrganizationInviteRedeemResponseError = (
| authOrganizationInviteRedeemResponse403
| authOrganizationInviteRedeemResponse409
) & {
headers: Headers;
};
export type authOrganizationInviteRedeemResponse =
| authOrganizationInviteRedeemResponseSuccess
| authOrganizationInviteRedeemResponseError;
export const getAuthOrganizationInviteRedeemUrl = () => {
return `/api/v1/organizations/invites/redeem`;
};
/**
* uses 递增与兑换记录写入同事务。定向邀请只能由目标用户兑换。
* @summary 兑换邀请
*/
export const authOrganizationInviteRedeem = async (
redeemInviteBody: RedeemInviteBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationInviteRedeemResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationInviteRedeemResponse>(
getAuthOrganizationInviteRedeemUrl(),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(redeemInviteBody),
},
);
};
export type authOrganizationGetResponse200 = {
data: EnvelopeOrganizationSummary;
status: 200;
};
export type authOrganizationGetResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationGetResponseSuccess =
authOrganizationGetResponse200 & {
headers: Headers;
};
export type authOrganizationGetResponseError =
authOrganizationGetResponse404 & {
headers: Headers;
};
export type authOrganizationGetResponse =
authOrganizationGetResponseSuccess | authOrganizationGetResponseError;
export const getAuthOrganizationGetUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}`;
};
/**
* @summary 组织详情
*/
export const authOrganizationGet = async (
organizationId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationGetResponse> => {
return authClient<authOrganizationGetResponse>(
getAuthOrganizationGetUrl(organizationId),
{
...options,
method: "GET",
},
);
};
export type authOrganizationDeleteResponse200 = {
data: EnvelopeBool;
status: 200;
};
export type authOrganizationDeleteResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationDeleteResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationDeleteResponseSuccess =
authOrganizationDeleteResponse200 & {
headers: Headers;
};
export type authOrganizationDeleteResponseError = (
authOrganizationDeleteResponse403 | authOrganizationDeleteResponse409
) & {
headers: Headers;
};
export type authOrganizationDeleteResponse =
authOrganizationDeleteResponseSuccess | authOrganizationDeleteResponseError;
export const getAuthOrganizationDeleteUrl = (
organizationId: string,
params?: AuthOrganizationDeleteParams,
) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : String(value));
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/organizations/${organizationId}?${stringifiedParams}`
: `/api/v1/organizations/${organizationId}`;
};
/**
* 仍存在活跃成员且未指定 `force=true` 时返回 409。删除会清理成员、角色与邀请。
* @summary 删除组织
*/
export const authOrganizationDelete = async (
organizationId: string,
params?: AuthOrganizationDeleteParams,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationDeleteResponse> => {
return authClient<authOrganizationDeleteResponse>(
getAuthOrganizationDeleteUrl(organizationId, params),
{
...options,
method: "DELETE",
},
);
};
export type authOrganizationUpdateResponse200 = {
data: EnvelopeOrganizationSummary;
status: 200;
};
export type authOrganizationUpdateResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationUpdateResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationUpdateResponseSuccess =
authOrganizationUpdateResponse200 & {
headers: Headers;
};
export type authOrganizationUpdateResponseError = (
authOrganizationUpdateResponse403 | authOrganizationUpdateResponse409
) & {
headers: Headers;
};
export type authOrganizationUpdateResponse =
authOrganizationUpdateResponseSuccess | authOrganizationUpdateResponseError;
export const getAuthOrganizationUpdateUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}`;
};
/**
* 需要 `org.update`。`expected_version` 与当前 version 不一致时返回 409。
* @summary 修改组织
*/
export const authOrganizationUpdate = async (
organizationId: string,
updateOrganizationBody: UpdateOrganizationBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationUpdateResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationUpdateResponse>(
getAuthOrganizationUpdateUrl(organizationId),
{
...options,
method: "PATCH",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(updateOrganizationBody),
},
);
};
export type authOrganizationArchiveResponse200 = {
data: EnvelopeOrganizationSummary;
status: 200;
};
export type authOrganizationArchiveResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationArchiveResponseSuccess =
authOrganizationArchiveResponse200 & {
headers: Headers;
};
export type authOrganizationArchiveResponseError =
authOrganizationArchiveResponse403 & {
headers: Headers;
};
export type authOrganizationArchiveResponse =
authOrganizationArchiveResponseSuccess | authOrganizationArchiveResponseError;
export const getAuthOrganizationArchiveUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/archive`;
};
/**
* 需要 `org.archive`。归档后全部权限判定返回 false，可恢复。
* @summary 归档组织
*/
export const authOrganizationArchive = async (
organizationId: string,
reasonBody: ReasonBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationArchiveResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationArchiveResponse>(
getAuthOrganizationArchiveUrl(organizationId),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(reasonBody),
},
);
};
export type authOrganizationBanListResponse200 = {
data: EnvelopeVecMemberSummary;
status: 200;
};
export type authOrganizationBanListResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationBanListResponseSuccess =
authOrganizationBanListResponse200 & {
headers: Headers;
};
export type authOrganizationBanListResponseError =
authOrganizationBanListResponse403 & {
headers: Headers;
};
export type authOrganizationBanListResponse =
authOrganizationBanListResponseSuccess | authOrganizationBanListResponseError;
export const getAuthOrganizationBanListUrl = (
organizationId: string,
params?: AuthOrganizationBanListParams,
) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : String(value));
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/organizations/${organizationId}/bans?${stringifiedParams}`
: `/api/v1/organizations/${organizationId}/bans`;
};
/**
* 需要 `member.ban`。按封禁时间倒序。
* @summary 封禁列表
*/
export const authOrganizationBanList = async (
organizationId: string,
params?: AuthOrganizationBanListParams,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationBanListResponse> => {
return authClient<authOrganizationBanListResponse>(
getAuthOrganizationBanListUrl(organizationId, params),
{
...options,
method: "GET",
},
);
};
export type authOrganizationBanGetResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationBanGetResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationBanGetResponseSuccess =
authOrganizationBanGetResponse200 & {
headers: Headers;
};
export type authOrganizationBanGetResponseError =
authOrganizationBanGetResponse404 & {
headers: Headers;
};
export type authOrganizationBanGetResponse =
authOrganizationBanGetResponseSuccess | authOrganizationBanGetResponseError;
export const getAuthOrganizationBanGetUrl = (
organizationId: string,
userId: number,
) => {
return `/api/v1/organizations/${organizationId}/bans/${userId}`;
};
/**
* 需要 `member.ban`。未封禁返回 404。
* @summary 封禁详情
*/
export const authOrganizationBanGet = async (
organizationId: string,
userId: number,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationBanGetResponse> => {
return authClient<authOrganizationBanGetResponse>(
getAuthOrganizationBanGetUrl(organizationId, userId),
{
...options,
method: "GET",
},
);
};
export type authOrganizationBanDeleteResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationBanDeleteResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationBanDeleteResponseSuccess =
authOrganizationBanDeleteResponse200 & {
headers: Headers;
};
export type authOrganizationBanDeleteResponseError =
authOrganizationBanDeleteResponse404 & {
headers: Headers;
};
export type authOrganizationBanDeleteResponse =
| authOrganizationBanDeleteResponseSuccess
| authOrganizationBanDeleteResponseError;
export const getAuthOrganizationBanDeleteUrl = (
organizationId: string,
userId: number,
) => {
return `/api/v1/organizations/${organizationId}/bans/${userId}`;
};
/**
* 需要 `member.ban`。等价于按会籍 id 解封，便于按用户维度操作。
* @summary 按用户解封
*/
export const authOrganizationBanDelete = async (
organizationId: string,
userId: number,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationBanDeleteResponse> => {
return authClient<authOrganizationBanDeleteResponse>(
getAuthOrganizationBanDeleteUrl(organizationId, userId),
{
...options,
method: "DELETE",
},
);
};
export type authOrganizationBanUpdateResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationBanUpdateResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationBanUpdateResponseSuccess =
authOrganizationBanUpdateResponse200 & {
headers: Headers;
};
export type authOrganizationBanUpdateResponseError =
authOrganizationBanUpdateResponse404 & {
headers: Headers;
};
export type authOrganizationBanUpdateResponse =
| authOrganizationBanUpdateResponseSuccess
| authOrganizationBanUpdateResponseError;
export const getAuthOrganizationBanUpdateUrl = (
organizationId: string,
userId: number,
) => {
return `/api/v1/organizations/${organizationId}/bans/${userId}`;
};
/**
* 需要 `member.ban`。改原因、到期时间与四个放行位；未封禁返回 404。
* @summary 更新封禁
*/
export const authOrganizationBanUpdate = async (
organizationId: string,
userId: number,
updateBanBody: UpdateBanBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationBanUpdateResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationBanUpdateResponse>(
getAuthOrganizationBanUpdateUrl(organizationId, userId),
{
...options,
method: "PATCH",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(updateBanBody),
},
);
};
export type authOrganizationInviteListResponse200 = {
data: EnvelopeVecInviteSummary;
status: 200;
};
export type authOrganizationInviteListResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationInviteListResponseSuccess =
authOrganizationInviteListResponse200 & {
headers: Headers;
};
export type authOrganizationInviteListResponseError =
authOrganizationInviteListResponse403 & {
headers: Headers;
};
export type authOrganizationInviteListResponse =
| authOrganizationInviteListResponseSuccess
| authOrganizationInviteListResponseError;
export const getAuthOrganizationInviteListUrl = (
organizationId: string,
params?: AuthOrganizationInviteListParams,
) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : String(value));
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/organizations/${organizationId}/invites?${stringifiedParams}`
: `/api/v1/organizations/${organizationId}/invites`;
};
/**
* 需要 `invite.view`。不含 token 明文。
* @summary 列示邀请
*/
export const authOrganizationInviteList = async (
organizationId: string,
params?: AuthOrganizationInviteListParams,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationInviteListResponse> => {
return authClient<authOrganizationInviteListResponse>(
getAuthOrganizationInviteListUrl(organizationId, params),
{
...options,
method: "GET",
},
);
};
export type authOrganizationInviteCreateResponse200 = {
data: EnvelopeCreateInviteResponse;
status: 200;
};
export type authOrganizationInviteCreateResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationInviteCreateResponseSuccess =
authOrganizationInviteCreateResponse200 & {
headers: Headers;
};
export type authOrganizationInviteCreateResponseError =
authOrganizationInviteCreateResponse403 & {
headers: Headers;
};
export type authOrganizationInviteCreateResponse =
| authOrganizationInviteCreateResponseSuccess
| authOrganizationInviteCreateResponseError;
export const getAuthOrganizationInviteCreateUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/invites`;
};
/**
* 需要 `invite.create`。明文 token 只在创建响应里返回一次，之后只存 sha256。
* @summary 创建邀请
*/
export const authOrganizationInviteCreate = async (
organizationId: string,
createInviteBody: CreateInviteBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationInviteCreateResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationInviteCreateResponse>(
getAuthOrganizationInviteCreateUrl(organizationId),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(createInviteBody),
},
);
};
export type authOrganizationInviteRevokeResponse200 = {
data: EnvelopeBool;
status: 200;
};
export type authOrganizationInviteRevokeResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationInviteRevokeResponseSuccess =
authOrganizationInviteRevokeResponse200 & {
headers: Headers;
};
export type authOrganizationInviteRevokeResponseError =
authOrganizationInviteRevokeResponse404 & {
headers: Headers;
};
export type authOrganizationInviteRevokeResponse =
| authOrganizationInviteRevokeResponseSuccess
| authOrganizationInviteRevokeResponseError;
export const getAuthOrganizationInviteRevokeUrl = (
organizationId: string,
inviteId: string,
) => {
return `/api/v1/organizations/${organizationId}/invites/${inviteId}`;
};
/**
* 需要 `invite.revoke`。已撤销的邀请再次撤销返回 false。
* @summary 撤销邀请
*/
export const authOrganizationInviteRevoke = async (
organizationId: string,
inviteId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationInviteRevokeResponse> => {
return authClient<authOrganizationInviteRevokeResponse>(
getAuthOrganizationInviteRevokeUrl(organizationId, inviteId),
{
...options,
method: "DELETE",
},
);
};
export type authOrganizationLeaveResponse200 = {
data: EnvelopeBool;
status: 200;
};
export type authOrganizationLeaveResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationLeaveResponseSuccess =
authOrganizationLeaveResponse200 & {
headers: Headers;
};
export type authOrganizationLeaveResponseError =
authOrganizationLeaveResponse409 & {
headers: Headers;
};
export type authOrganizationLeaveResponse =
authOrganizationLeaveResponseSuccess | authOrganizationLeaveResponseError;
export const getAuthOrganizationLeaveUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/leave`;
};
/**
* OWNER 必须先转移所有权，否则返回 409。
* @summary 退出组织
*/
export const authOrganizationLeave = async (
organizationId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationLeaveResponse> => {
return authClient<authOrganizationLeaveResponse>(
getAuthOrganizationLeaveUrl(organizationId),
{
...options,
method: "POST",
},
);
};
export type authOrganizationMemberListResponse200 = {
data: EnvelopeVecMemberSummary;
status: 200;
};
export type authOrganizationMemberListResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationMemberListResponseSuccess =
authOrganizationMemberListResponse200 & {
headers: Headers;
};
export type authOrganizationMemberListResponseError =
authOrganizationMemberListResponse403 & {
headers: Headers;
};
export type authOrganizationMemberListResponse =
| authOrganizationMemberListResponseSuccess
| authOrganizationMemberListResponseError;
export const getAuthOrganizationMemberListUrl = (
organizationId: string,
params?: AuthOrganizationMemberListParams,
) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : String(value));
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/organizations/${organizationId}/members?${stringifiedParams}`
: `/api/v1/organizations/${organizationId}/members`;
};
/**
* 需要 `member.view`。默认只返回活跃成员。
* @summary 列示组织成员
*/
export const authOrganizationMemberList = async (
organizationId: string,
params?: AuthOrganizationMemberListParams,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberListResponse> => {
return authClient<authOrganizationMemberListResponse>(
getAuthOrganizationMemberListUrl(organizationId, params),
{
...options,
method: "GET",
},
);
};
export type authOrganizationMemberAddResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationMemberAddResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationMemberAddResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationMemberAddResponseSuccess =
authOrganizationMemberAddResponse200 & {
headers: Headers;
};
export type authOrganizationMemberAddResponseError = (
authOrganizationMemberAddResponse403 | authOrganizationMemberAddResponse404
) & {
headers: Headers;
};
export type authOrganizationMemberAddResponse =
| authOrganizationMemberAddResponseSuccess
| authOrganizationMemberAddResponseError;
export const getAuthOrganizationMemberAddUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/members`;
};
/**
* 需要 `member.add`。已退出的会籍按复活处理，已封禁的返回 403。
* @summary 直接添加成员
*/
export const authOrganizationMemberAdd = async (
organizationId: string,
addMemberBody: AddMemberBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberAddResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationMemberAddResponse>(
getAuthOrganizationMemberAddUrl(organizationId),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(addMemberBody),
},
);
};
export type authOrganizationMemberUpdateSelfResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationMemberUpdateSelfResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationMemberUpdateSelfResponseSuccess =
authOrganizationMemberUpdateSelfResponse200 & {
headers: Headers;
};
export type authOrganizationMemberUpdateSelfResponseError =
authOrganizationMemberUpdateSelfResponse403 & {
headers: Headers;
};
export type authOrganizationMemberUpdateSelfResponse =
| authOrganizationMemberUpdateSelfResponseSuccess
| authOrganizationMemberUpdateSelfResponseError;
export const getAuthOrganizationMemberUpdateSelfUrl = (
organizationId: string,
) => {
return `/api/v1/organizations/${organizationId}/members/@me`;
};
/**
* 只允许修改自己的别名、头像与通知偏好；无需 `member.role.update`。
* @summary 更新自己的会籍资料
*/
export const authOrganizationMemberUpdateSelf = async (
organizationId: string,
updateMemberBody: UpdateMemberBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberUpdateSelfResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationMemberUpdateSelfResponse>(
getAuthOrganizationMemberUpdateSelfUrl(organizationId),
{
...options,
method: "PATCH",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(updateMemberBody),
},
);
};
export type authOrganizationMemberGetResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationMemberGetResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationMemberGetResponseSuccess =
authOrganizationMemberGetResponse200 & {
headers: Headers;
};
export type authOrganizationMemberGetResponseError =
authOrganizationMemberGetResponse404 & {
headers: Headers;
};
export type authOrganizationMemberGetResponse =
| authOrganizationMemberGetResponseSuccess
| authOrganizationMemberGetResponseError;
export const getAuthOrganizationMemberGetUrl = (
organizationId: string,
memberId: string,
) => {
return `/api/v1/organizations/${organizationId}/members/${memberId}`;
};
/**
* 需要 `member.view`。包含别名、通知偏好与封禁附加信息。
* @summary 成员详情
*/
export const authOrganizationMemberGet = async (
organizationId: string,
memberId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberGetResponse> => {
return authClient<authOrganizationMemberGetResponse>(
getAuthOrganizationMemberGetUrl(organizationId, memberId),
{
...options,
method: "GET",
},
);
};
export type authOrganizationMemberRemoveResponse200 = {
data: EnvelopeBool;
status: 200;
};
export type authOrganizationMemberRemoveResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationMemberRemoveResponseSuccess =
authOrganizationMemberRemoveResponse200 & {
headers: Headers;
};
export type authOrganizationMemberRemoveResponseError =
authOrganizationMemberRemoveResponse403 & {
headers: Headers;
};
export type authOrganizationMemberRemoveResponse =
| authOrganizationMemberRemoveResponseSuccess
| authOrganizationMemberRemoveResponseError;
export const getAuthOrganizationMemberRemoveUrl = (
organizationId: string,
memberId: string,
params?: AuthOrganizationMemberRemoveParams,
) => {
const normalizedParams = new URLSearchParams();
Object.entries(params || {}).forEach(([key, value]) => {
if (value !== undefined) {
normalizedParams.append(key, value === null ? "null" : String(value));
}
});
const stringifiedParams = normalizedParams.toString();
return stringifiedParams.length > 0
? `/api/v1/organizations/${organizationId}/members/${memberId}?${stringifiedParams}`
: `/api/v1/organizations/${organizationId}/members/${memberId}`;
};
/**
* 需要 `member.remove`。OWNER 不能移除，需先转移所有权。会籍行保留用于复活。
* @summary 移除成员
*/
export const authOrganizationMemberRemove = async (
organizationId: string,
memberId: string,
params?: AuthOrganizationMemberRemoveParams,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberRemoveResponse> => {
return authClient<authOrganizationMemberRemoveResponse>(
getAuthOrganizationMemberRemoveUrl(organizationId, memberId, params),
{
...options,
method: "DELETE",
},
);
};
export type authOrganizationMemberUpdateResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationMemberUpdateResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationMemberUpdateResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationMemberUpdateResponseSuccess =
authOrganizationMemberUpdateResponse200 & {
headers: Headers;
};
export type authOrganizationMemberUpdateResponseError = (
| authOrganizationMemberUpdateResponse403
| authOrganizationMemberUpdateResponse409
) & {
headers: Headers;
};
export type authOrganizationMemberUpdateResponse =
| authOrganizationMemberUpdateResponseSuccess
| authOrganizationMemberUpdateResponseError;
export const getAuthOrganizationMemberUpdateUrl = (
organizationId: string,
memberId: string,
) => {
return `/api/v1/organizations/${organizationId}/members/${memberId}`;
};
/**
* 需要 `member.role.update`。修改别名、头像、通知偏好与免打扰；封禁中的会籍走封禁接口。
* @summary 更新成员资料
*/
export const authOrganizationMemberUpdate = async (
organizationId: string,
memberId: string,
updateMemberBody: UpdateMemberBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberUpdateResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationMemberUpdateResponse>(
getAuthOrganizationMemberUpdateUrl(organizationId, memberId),
{
...options,
method: "PATCH",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(updateMemberBody),
},
);
};
export type authOrganizationMemberBanResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationMemberBanResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationMemberBanResponseSuccess =
authOrganizationMemberBanResponse200 & {
headers: Headers;
};
export type authOrganizationMemberBanResponseError =
authOrganizationMemberBanResponse403 & {
headers: Headers;
};
export type authOrganizationMemberBanResponse =
| authOrganizationMemberBanResponseSuccess
| authOrganizationMemberBanResponseError;
export const getAuthOrganizationMemberBanUrl = (
organizationId: string,
memberId: string,
) => {
return `/api/v1/organizations/${organizationId}/members/${memberId}/ban`;
};
/**
* 写 banned_at 并清空角色绑定与直挂权限。封禁优先于一切授权。
* @summary 封禁成员
*/
export const authOrganizationMemberBan = async (
organizationId: string,
memberId: string,
banMemberBody: BanMemberBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberBanResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationMemberBanResponse>(
getAuthOrganizationMemberBanUrl(organizationId, memberId),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(banMemberBody),
},
);
};
export type authOrganizationMemberPermissionsResponse200 = {
data: EnvelopeVecString;
status: 200;
};
export type authOrganizationMemberPermissionsResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationMemberPermissionsResponseSuccess =
authOrganizationMemberPermissionsResponse200 & {
headers: Headers;
};
export type authOrganizationMemberPermissionsResponseError =
authOrganizationMemberPermissionsResponse403 & {
headers: Headers;
};
export type authOrganizationMemberPermissionsResponse =
| authOrganizationMemberPermissionsResponseSuccess
| authOrganizationMemberPermissionsResponseError;
export const getAuthOrganizationMemberPermissionsUrl = (
organizationId: string,
memberId: string,
) => {
return `/api/v1/organizations/${organizationId}/members/${memberId}/permissions`;
};
/**
* 整表替换语义。需要 `role.permission.update`，OWNER 不接受直挂覆盖。
* @summary 设置成员直挂权限
*/
export const authOrganizationMemberPermissions = async (
organizationId: string,
memberId: string,
setRolePermissionsBody: SetRolePermissionsBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberPermissionsResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationMemberPermissionsResponse>(
getAuthOrganizationMemberPermissionsUrl(organizationId, memberId),
{
...options,
method: "PUT",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(setRolePermissionsBody),
},
);
};
export type authOrganizationMemberRoleResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationMemberRoleResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationMemberRoleResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationMemberRoleResponseSuccess =
authOrganizationMemberRoleResponse200 & {
headers: Headers;
};
export type authOrganizationMemberRoleResponseError = (
authOrganizationMemberRoleResponse403 | authOrganizationMemberRoleResponse409
) & {
headers: Headers;
};
export type authOrganizationMemberRoleResponse =
| authOrganizationMemberRoleResponseSuccess
| authOrganizationMemberRoleResponseError;
export const getAuthOrganizationMemberRoleUrl = (
organizationId: string,
memberId: string,
) => {
return `/api/v1/organizations/${organizationId}/members/${memberId}/role`;
};
/**
* 只接受 MEMBER 与 ADMIN。OWNER 只能通过转移所有权变更。
* @summary 改粗粒度角色
*/
export const authOrganizationMemberRole = async (
organizationId: string,
memberId: string,
setMemberRoleBody: SetMemberRoleBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberRoleResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationMemberRoleResponse>(
getAuthOrganizationMemberRoleUrl(organizationId, memberId),
{
...options,
method: "PATCH",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(setMemberRoleBody),
},
);
};
export type authOrganizationMemberUnbanResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationMemberUnbanResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationMemberUnbanResponseSuccess =
authOrganizationMemberUnbanResponse200 & {
headers: Headers;
};
export type authOrganizationMemberUnbanResponseError =
authOrganizationMemberUnbanResponse403 & {
headers: Headers;
};
export type authOrganizationMemberUnbanResponse =
| authOrganizationMemberUnbanResponseSuccess
| authOrganizationMemberUnbanResponseError;
export const getAuthOrganizationMemberUnbanUrl = (
organizationId: string,
memberId: string,
) => {
return `/api/v1/organizations/${organizationId}/members/${memberId}/unban`;
};
/**
* 清空 banned_at。已清空的角色不会自动恢复。
* @summary 解封成员
*/
export const authOrganizationMemberUnban = async (
organizationId: string,
memberId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationMemberUnbanResponse> => {
return authClient<authOrganizationMemberUnbanResponse>(
getAuthOrganizationMemberUnbanUrl(organizationId, memberId),
{
...options,
method: "POST",
},
);
};
export type authOrganizationPermissionCheckResponse200 = {
data: EnvelopePermissionCheck;
status: 200;
};
export type authOrganizationPermissionCheckResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationPermissionCheckResponseSuccess =
authOrganizationPermissionCheckResponse200 & {
headers: Headers;
};
export type authOrganizationPermissionCheckResponseError =
authOrganizationPermissionCheckResponse403 & {
headers: Headers;
};
export type authOrganizationPermissionCheckResponse =
| authOrganizationPermissionCheckResponseSuccess
| authOrganizationPermissionCheckResponseError;
export const getAuthOrganizationPermissionCheckUrl = (
organizationId: string,
) => {
return `/api/v1/organizations/${organizationId}/permissions/check`;
};
/**
* 拒绝不作为错误返回：`allowed=false` 附 `reason` 与 `matched_by`，便于调用方聚合。
* @summary 单权限判定
*/
export const authOrganizationPermissionCheck = async (
organizationId: string,
checkPermissionBody: CheckPermissionBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationPermissionCheckResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationPermissionCheckResponse>(
getAuthOrganizationPermissionCheckUrl(organizationId),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(checkPermissionBody),
},
);
};
export type authOrganizationRestoreResponse200 = {
data: EnvelopeOrganizationSummary;
status: 200;
};
export type authOrganizationRestoreResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationRestoreResponseSuccess =
authOrganizationRestoreResponse200 & {
headers: Headers;
};
export type authOrganizationRestoreResponseError =
authOrganizationRestoreResponse403 & {
headers: Headers;
};
export type authOrganizationRestoreResponse =
authOrganizationRestoreResponseSuccess | authOrganizationRestoreResponseError;
export const getAuthOrganizationRestoreUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/restore`;
};
/**
* 仅 OWNER 或平台管理员可执行。
* @summary 恢复归档组织
*/
export const authOrganizationRestore = async (
organizationId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRestoreResponse> => {
return authClient<authOrganizationRestoreResponse>(
getAuthOrganizationRestoreUrl(organizationId),
{
...options,
method: "POST",
},
);
};
export type authOrganizationRoleListResponse200 = {
data: EnvelopeVecRoleSummary;
status: 200;
};
export type authOrganizationRoleListResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationRoleListResponseSuccess =
authOrganizationRoleListResponse200 & {
headers: Headers;
};
export type authOrganizationRoleListResponseError =
authOrganizationRoleListResponse403 & {
headers: Headers;
};
export type authOrganizationRoleListResponse =
| authOrganizationRoleListResponseSuccess
| authOrganizationRoleListResponseError;
export const getAuthOrganizationRoleListUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/roles`;
};
/**
* 需要 `role.view`。含内置 owner/admin/member 三个系统角色。
* @summary 列示组织角色
*/
export const authOrganizationRoleList = async (
organizationId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRoleListResponse> => {
return authClient<authOrganizationRoleListResponse>(
getAuthOrganizationRoleListUrl(organizationId),
{
...options,
method: "GET",
},
);
};
export type authOrganizationRoleCreateResponse200 = {
data: EnvelopeRoleSummary;
status: 200;
};
export type authOrganizationRoleCreateResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationRoleCreateResponseSuccess =
authOrganizationRoleCreateResponse200 & {
headers: Headers;
};
export type authOrganizationRoleCreateResponseError =
authOrganizationRoleCreateResponse409 & {
headers: Headers;
};
export type authOrganizationRoleCreateResponse =
| authOrganizationRoleCreateResponseSuccess
| authOrganizationRoleCreateResponseError;
export const getAuthOrganizationRoleCreateUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/roles`;
};
/**
* 需要 `role.create`。key 在组织内唯一，权限键必须在白名单内。
* @summary 新建角色
*/
export const authOrganizationRoleCreate = async (
organizationId: string,
createRoleBody: CreateRoleBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRoleCreateResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationRoleCreateResponse>(
getAuthOrganizationRoleCreateUrl(organizationId),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(createRoleBody),
},
);
};
export type authOrganizationRoleAssignResponse200 = {
data: EnvelopeVecString;
status: 200;
};
export type authOrganizationRoleAssignResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationRoleAssignResponseSuccess =
authOrganizationRoleAssignResponse200 & {
headers: Headers;
};
export type authOrganizationRoleAssignResponseError =
authOrganizationRoleAssignResponse404 & {
headers: Headers;
};
export type authOrganizationRoleAssignResponse =
| authOrganizationRoleAssignResponseSuccess
| authOrganizationRoleAssignResponseError;
export const getAuthOrganizationRoleAssignUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/roles/assign`;
};
/**
* 需要 `role.assign`。重复绑定幂等。
* @summary 绑定角色到成员
*/
export const authOrganizationRoleAssign = async (
organizationId: string,
assignRoleBody: AssignRoleBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRoleAssignResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationRoleAssignResponse>(
getAuthOrganizationRoleAssignUrl(organizationId),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(assignRoleBody),
},
);
};
export type authOrganizationRoleUnassignResponse200 = {
data: EnvelopeVecString;
status: 200;
};
export type authOrganizationRoleUnassignResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationRoleUnassignResponseSuccess =
authOrganizationRoleUnassignResponse200 & {
headers: Headers;
};
export type authOrganizationRoleUnassignResponseError =
authOrganizationRoleUnassignResponse403 & {
headers: Headers;
};
export type authOrganizationRoleUnassignResponse =
| authOrganizationRoleUnassignResponseSuccess
| authOrganizationRoleUnassignResponseError;
export const getAuthOrganizationRoleUnassignUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/roles/unassign`;
};
/**
* 需要 `role.assign`。系统角色不可解绑。
* @summary 解绑成员角色
*/
export const authOrganizationRoleUnassign = async (
organizationId: string,
assignRoleBody: AssignRoleBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRoleUnassignResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationRoleUnassignResponse>(
getAuthOrganizationRoleUnassignUrl(organizationId),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(assignRoleBody),
},
);
};
export type authOrganizationRoleGetResponse200 = {
data: EnvelopeRoleSummary;
status: 200;
};
export type authOrganizationRoleGetResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationRoleGetResponseSuccess =
authOrganizationRoleGetResponse200 & {
headers: Headers;
};
export type authOrganizationRoleGetResponseError =
authOrganizationRoleGetResponse404 & {
headers: Headers;
};
export type authOrganizationRoleGetResponse =
authOrganizationRoleGetResponseSuccess | authOrganizationRoleGetResponseError;
export const getAuthOrganizationRoleGetUrl = (
organizationId: string,
roleId: string,
) => {
return `/api/v1/organizations/${organizationId}/roles/${roleId}`;
};
/**
* 需要 `role.view`。
* @summary 角色详情
*/
export const authOrganizationRoleGet = async (
organizationId: string,
roleId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRoleGetResponse> => {
return authClient<authOrganizationRoleGetResponse>(
getAuthOrganizationRoleGetUrl(organizationId, roleId),
{
...options,
method: "GET",
},
);
};
export type authOrganizationRoleDeleteResponse200 = {
data: EnvelopeBool;
status: 200;
};
export type authOrganizationRoleDeleteResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationRoleDeleteResponseSuccess =
authOrganizationRoleDeleteResponse200 & {
headers: Headers;
};
export type authOrganizationRoleDeleteResponseError =
authOrganizationRoleDeleteResponse409 & {
headers: Headers;
};
export type authOrganizationRoleDeleteResponse =
| authOrganizationRoleDeleteResponseSuccess
| authOrganizationRoleDeleteResponseError;
export const getAuthOrganizationRoleDeleteUrl = (
organizationId: string,
roleId: string,
) => {
return `/api/v1/organizations/${organizationId}/roles/${roleId}`;
};
/**
* 需要 `role.delete`。系统角色不可删；仍有成员绑定时返回 409。
* @summary 删除角色
*/
export const authOrganizationRoleDelete = async (
organizationId: string,
roleId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRoleDeleteResponse> => {
return authClient<authOrganizationRoleDeleteResponse>(
getAuthOrganizationRoleDeleteUrl(organizationId, roleId),
{
...options,
method: "DELETE",
},
);
};
export type authOrganizationRoleUpdateResponse200 = {
data: EnvelopeRoleSummary;
status: 200;
};
export type authOrganizationRoleUpdateResponse409 = {
data: EnvelopeNoData;
status: 409;
};
export type authOrganizationRoleUpdateResponseSuccess =
authOrganizationRoleUpdateResponse200 & {
headers: Headers;
};
export type authOrganizationRoleUpdateResponseError =
authOrganizationRoleUpdateResponse409 & {
headers: Headers;
};
export type authOrganizationRoleUpdateResponse =
| authOrganizationRoleUpdateResponseSuccess
| authOrganizationRoleUpdateResponseError;
export const getAuthOrganizationRoleUpdateUrl = (
organizationId: string,
roleId: string,
) => {
return `/api/v1/organizations/${organizationId}/roles/${roleId}`;
};
/**
* 需要 `role.update`。OWNER 系统角色不允许改 rank 与 default_role。
* @summary 修改角色
*/
export const authOrganizationRoleUpdate = async (
organizationId: string,
roleId: string,
updateRoleBody: UpdateRoleBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRoleUpdateResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationRoleUpdateResponse>(
getAuthOrganizationRoleUpdateUrl(organizationId, roleId),
{
...options,
method: "PATCH",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(updateRoleBody),
},
);
};
export type authOrganizationRoleJoinResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationRoleJoinResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationRoleJoinResponseSuccess =
authOrganizationRoleJoinResponse200 & {
headers: Headers;
};
export type authOrganizationRoleJoinResponseError =
authOrganizationRoleJoinResponse403 & {
headers: Headers;
};
export type authOrganizationRoleJoinResponse =
| authOrganizationRoleJoinResponseSuccess
| authOrganizationRoleJoinResponseError;
export const getAuthOrganizationRoleJoinUrl = (
organizationId: string,
roleId: string,
) => {
return `/api/v1/organizations/${organizationId}/roles/${roleId}/join`;
};
/**
* 只允许 `self_assignable = true` 的非内置角色。
* @summary 自助加入角色
*/
export const authOrganizationRoleJoin = async (
organizationId: string,
roleId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRoleJoinResponse> => {
return authClient<authOrganizationRoleJoinResponse>(
getAuthOrganizationRoleJoinUrl(organizationId, roleId),
{
...options,
method: "POST",
},
);
};
export type authOrganizationRoleLeaveResponse200 = {
data: EnvelopeMemberSummary;
status: 200;
};
export type authOrganizationRoleLeaveResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationRoleLeaveResponseSuccess =
authOrganizationRoleLeaveResponse200 & {
headers: Headers;
};
export type authOrganizationRoleLeaveResponseError =
authOrganizationRoleLeaveResponse403 & {
headers: Headers;
};
export type authOrganizationRoleLeaveResponse =
| authOrganizationRoleLeaveResponseSuccess
| authOrganizationRoleLeaveResponseError;
export const getAuthOrganizationRoleLeaveUrl = (
organizationId: string,
roleId: string,
) => {
return `/api/v1/organizations/${organizationId}/roles/${roleId}/join`;
};
/**
* 只允许 `self_assignable = true` 的非内置角色；重复退出视为成功。
* @summary 自助退出角色
*/
export const authOrganizationRoleLeave = async (
organizationId: string,
roleId: string,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRoleLeaveResponse> => {
return authClient<authOrganizationRoleLeaveResponse>(
getAuthOrganizationRoleLeaveUrl(organizationId, roleId),
{
...options,
method: "DELETE",
},
);
};
export type authOrganizationRolePermissionsResponse200 = {
data: EnvelopeRoleSummary;
status: 200;
};
export type authOrganizationRolePermissionsResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationRolePermissionsResponseSuccess =
authOrganizationRolePermissionsResponse200 & {
headers: Headers;
};
export type authOrganizationRolePermissionsResponseError =
authOrganizationRolePermissionsResponse403 & {
headers: Headers;
};
export type authOrganizationRolePermissionsResponse =
| authOrganizationRolePermissionsResponseSuccess
| authOrganizationRolePermissionsResponseError;
export const getAuthOrganizationRolePermissionsUrl = (
organizationId: string,
roleId: string,
) => {
return `/api/v1/organizations/${organizationId}/roles/${roleId}/permissions`;
};
/**
* 整体替换语义，是角色权限的唯一写入口。需要 `role.permission.update`。
* @summary 设置角色权限
*/
export const authOrganizationRolePermissions = async (
organizationId: string,
roleId: string,
setRolePermissionsBody: SetRolePermissionsBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationRolePermissionsResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationRolePermissionsResponse>(
getAuthOrganizationRolePermissionsUrl(organizationId, roleId),
{
...options,
method: "PUT",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(setRolePermissionsBody),
},
);
};
export type authOrganizationTransferResponse200 = {
data: EnvelopeOrganizationSummary;
status: 200;
};
export type authOrganizationTransferResponse403 = {
data: EnvelopeNoData;
status: 403;
};
export type authOrganizationTransferResponse404 = {
data: EnvelopeNoData;
status: 404;
};
export type authOrganizationTransferResponseSuccess =
authOrganizationTransferResponse200 & {
headers: Headers;
};
export type authOrganizationTransferResponseError = (
authOrganizationTransferResponse403 | authOrganizationTransferResponse404
) & {
headers: Headers;
};
export type authOrganizationTransferResponse =
| authOrganizationTransferResponseSuccess
| authOrganizationTransferResponseError;
export const getAuthOrganizationTransferUrl = (organizationId: string) => {
return `/api/v1/organizations/${organizationId}/transfer`;
};
/**
* 目标必须是活跃成员。原 Owner 降为 ADMIN。
* @summary 转移 OWNER
*/
export const authOrganizationTransfer = async (
organizationId: string,
transferBody: TransferBody,
options?: Parameters<typeof authClient>[1],
): Promise<authOrganizationTransferResponse> => {
const getHeaders = (
h?: NonNullable<RequestInit["headers"]>,
): Record<string, string | readonly string[]> => {
if (!h) return {};
if (h instanceof Headers) return Object.fromEntries(h.entries());
if (Symbol.iterator in h) {
return Object.fromEntries(
Array.from(
h as Iterable<Iterable<string>>,
(entry) => Array.from(entry) as [string, string],
),
);
}
const headers: Record<string, string | readonly string[]> = {};
for (const [name, value] of Object.entries<
string | readonly string[] | undefined
>(h)) {
if (value !== undefined) headers[name] = value;
}
return headers;
};
return authClient<authOrganizationTransferResponse>(
getAuthOrganizationTransferUrl(organizationId),
{
...options,
method: "POST",
headers: {
"Content-Type": "application/json",
...getHeaders(options?.headers),
},
body: JSON.stringify(transferBody),
},
);
};
export type healthLiveResponse200 = {
data: EnvelopeHealthResponse;
status: 200;
};
export type healthLiveResponseSuccess = healthLiveResponse200 & {
headers: Headers;
};
export type healthLiveResponse = healthLiveResponseSuccess;
export const getHealthLiveUrl = () => {
return `/health`;
};
/**
* 只回答进程是否还在处理请求，不触碰任何外部依赖：数据库、Redis、RocketMQ 全都不可用时依然返回 200。用于区分「进程死了」和「依赖挂了」。
* @summary 存活探针
*/
export const healthLive = async (
options?: Parameters<typeof authClient>[1],
): Promise<healthLiveResponse> => {
return authClient<healthLiveResponse>(getHealthLiveUrl(), {
...options,
method: "GET",
});
};
export type healthReadyResponse200 = {
data: EnvelopeReadinessResponse;
status: 200;
};
export type healthReadyResponse503 = {
data: EnvelopeReadinessResponse;
status: 503;
};
export type healthReadyResponseSuccess = healthReadyResponse200 & {
headers: Headers;
};
export type healthReadyResponseError = healthReadyResponse503 & {
headers: Headers;
};
export type healthReadyResponse =
healthReadyResponseSuccess | healthReadyResponseError;
export const getHealthReadyUrl = () => {
return `/ready`;
};
/**
* 并发探测启动时必须连上的三个依赖——PostgreSQL、Redis、RocketMQ，全部可用返回 200，任一不可用返回 503 并在 `checks` 里标出是哪一项。单项探测上限 2 秒，失败细节只写日志，不进响应体。
* @summary 就绪探针
*/
export const healthReady = async (
options?: Parameters<typeof authClient>[1],
): Promise<healthReadyResponse> => {
return authClient<healthReadyResponse>(getHealthReadyUrl(), {
...options,
method: "GET",
});
};