@clossir-tech/ts-sdk 0.7.0 → 0.9.0

package/src/models/operations/index.ts

@@ -44,6 +44,7 @@ export * from "./get-compliance-by-wallet.js";
 export * from "./get-compliance-dossier-by-wallet-address.js";
 export * from "./get-compliance-transfer-rejections.js";
 export * from "./get-consent.js";
+export * from "./get-health-deep.js";
 export * from "./get-health.js";
 export * from "./get-jurisdictions-by-alpha2.js";
 export * from "./get-jurisdictions.js";
@@ -53,6 +54,7 @@ export * from "./get-login.js";
 export * from "./get-markets.js";
 export * from "./get-oauth-authorize.js";
 export * from "./get-oauth-userinfo.js";
+export * from "./get-orgs-by-org-id-api-keys-audit.js";
 export * from "./get-orgs-by-org-id-api-keys.js";
 export * from "./get-orgs-by-org-id-assets-by-asset-id-bridge-quote.js";
 export * from "./get-orgs-by-org-id-assets-by-asset-id-collateral.js";
@@ -166,6 +168,7 @@ export * from "./post-login.js";
 export * from "./post-oauth-authorize-callback.js";
 export * from "./post-oauth-revoke.js";
 export * from "./post-oauth-token.js";
+export * from "./post-orgs-by-org-id-api-keys-by-key-id-rotate.js";
 export * from "./post-orgs-by-org-id-api-keys.js";
 export * from "./post-orgs-by-org-id-assets-by-asset-id-allocate.js";
 export * from "./post-orgs-by-org-id-assets-by-asset-id-bridge.js";
@@ -191,6 +194,7 @@ export * from "./post-orgs-by-org-id-invitations-by-invitation-id-revoke.js";
 export * from "./post-orgs-by-org-id-invite-eligibility.js";
 export * from "./post-orgs-by-org-id-issuer-register.js";
 export * from "./post-orgs-by-org-id-members-by-user-id-attest.js";
+export * from "./post-orgs-by-org-id-members-by-user-id-server-wallet.js";
 export * from "./post-orgs-by-org-id-members-invite.js";
 export * from "./post-orgs-by-org-id-members.js";
 export * from "./post-orgs-by-org-id-oauth-clients-by-client-id-rotate-secret.js";
@@ -199,6 +203,7 @@ export * from "./post-orgs-by-org-id-server-wallet.js";
 export * from "./post-orgs-by-org-id-sub-orgs.js";
 export * from "./post-orgs-by-org-id-wallets.js";
 export * from "./post-orgs.js";
+export * from "./post-preflight.js";
 export * from "./post-register.js";
 export * from "./post-transfers.js";
 export * from "./post-uploads-presigned.js";

package/src/models/operations/post-attestations.ts

@@ -44,18 +44,6 @@ export type PostAttestationsRequest = {
   riskScore?: number | undefined;
 };
 
-export const PostAttestationsError = {
-  Unauthorized: "unauthorized",
-} as const;
-export type PostAttestationsError = ClosedEnum<typeof PostAttestationsError>;
-
-export const PostAttestationsBadRequestError = {
-  Unauthorized: "unauthorized",
-} as const;
-export type PostAttestationsBadRequestError = ClosedEnum<
-  typeof PostAttestationsBadRequestError
->;
-
 export const PostAttestationsStatus = {
   Pending: "pending",
 } as const;
@@ -109,16 +97,6 @@ export function postAttestationsRequestToJSON(
   );
 }
 
-/** @internal */
-export const PostAttestationsError$inboundSchema: z.ZodMiniEnum<
-  typeof PostAttestationsError
-> = z.enum(PostAttestationsError);
-
-/** @internal */
-export const PostAttestationsBadRequestError$inboundSchema: z.ZodMiniEnum<
-  typeof PostAttestationsBadRequestError
-> = z.enum(PostAttestationsBadRequestError);
-
 /** @internal */
 export const PostAttestationsStatus$inboundSchema: z.ZodMiniEnum<
   typeof PostAttestationsStatus

package/src/models/operations/post-chains-sync.ts

@@ -4,25 +4,10 @@
 
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
-export const PostChainsSyncForbiddenError = {
-  Forbidden: "forbidden",
-} as const;
-export type PostChainsSyncForbiddenError = ClosedEnum<
-  typeof PostChainsSyncForbiddenError
->;
-
-export const PostChainsSyncUnauthorizedError = {
-  Unauthorized: "unauthorized",
-} as const;
-export type PostChainsSyncUnauthorizedError = ClosedEnum<
-  typeof PostChainsSyncUnauthorizedError
->;
-
 /**
  * Response
  */
@@ -34,16 +19,6 @@ export type PostChainsSyncResponse = {
   synced: number;
 };
 
-/** @internal */
-export const PostChainsSyncForbiddenError$inboundSchema: z.ZodMiniEnum<
-  typeof PostChainsSyncForbiddenError
-> = z.enum(PostChainsSyncForbiddenError);
-
-/** @internal */
-export const PostChainsSyncUnauthorizedError$inboundSchema: z.ZodMiniEnum<
-  typeof PostChainsSyncUnauthorizedError
-> = z.enum(PostChainsSyncUnauthorizedError);
-
 /** @internal */
 export const PostChainsSyncResponse$inboundSchema: z.ZodMiniType<
   PostChainsSyncResponse,

package/src/models/operations/post-compliance-check.ts

@@ -4,7 +4,6 @@
 
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { smartUnion } from "../../types/smart-union.js";
@@ -30,13 +29,6 @@ export type PostComplianceCheckRequest = {
   assetId?: string | undefined;
 };
 
-export const PostComplianceCheckError = {
-  Unauthorized: "unauthorized",
-} as const;
-export type PostComplianceCheckError = ClosedEnum<
-  typeof PostComplianceCheckError
->;
-
 /**
  * Response
  */
@@ -90,11 +82,6 @@ export function postComplianceCheckRequestToJSON(
   );
 }
 
-/** @internal */
-export const PostComplianceCheckError$inboundSchema: z.ZodMiniEnum<
-  typeof PostComplianceCheckError
-> = z.enum(PostComplianceCheckError);
-
 /** @internal */
 export const PostComplianceCheckResponse$inboundSchema: z.ZodMiniType<
   PostComplianceCheckResponse,

package/src/models/operations/post-kyc-access-token.ts

@@ -58,13 +58,6 @@ export type PostKycAccessTokenRequest = {
     | PostKycAccessTokenLevelInstitutional;
 };
 
-export const PostKycAccessTokenError = {
-  Unauthorized: "unauthorized",
-} as const;
-export type PostKycAccessTokenError = ClosedEnum<
-  typeof PostKycAccessTokenError
->;
-
 /**
  * Response
  */
@@ -149,11 +142,6 @@ export function postKycAccessTokenRequestToJSON(
   );
 }
 
-/** @internal */
-export const PostKycAccessTokenError$inboundSchema: z.ZodMiniEnum<
-  typeof PostKycAccessTokenError
-> = z.enum(PostKycAccessTokenError);
-
 /** @internal */
 export const PostKycAccessTokenResponse$inboundSchema: z.ZodMiniType<
   PostKycAccessTokenResponse,

package/src/models/operations/post-kyc-initiate.ts

@@ -74,11 +74,6 @@ export type PostKycInitiateRequest = {
   userInfo?: UserInfo | undefined;
 };
 
-export const PostKycInitiateError = {
-  Unauthorized: "unauthorized",
-} as const;
-export type PostKycInitiateError = ClosedEnum<typeof PostKycInitiateError>;
-
 /**
  * Response
  */
@@ -206,11 +201,6 @@ export function postKycInitiateRequestToJSON(
   );
 }
 
-/** @internal */
-export const PostKycInitiateError$inboundSchema: z.ZodMiniEnum<
-  typeof PostKycInitiateError
-> = z.enum(PostKycInitiateError);
-
 /** @internal */
 export const PostKycInitiateResponse$inboundSchema: z.ZodMiniType<
   PostKycInitiateResponse,

package/src/models/operations/post-kyc-mock-approve.ts

@@ -59,20 +59,6 @@ export type PostKycMockApproveRequest = {
     | undefined;
 };
 
-export const PostKycMockApproveNotFoundError = {
-  NotFound: "not_found",
-} as const;
-export type PostKycMockApproveNotFoundError = ClosedEnum<
-  typeof PostKycMockApproveNotFoundError
->;
-
-export const PostKycMockApproveUnauthorizedError = {
-  Unauthorized: "unauthorized",
-} as const;
-export type PostKycMockApproveUnauthorizedError = ClosedEnum<
-  typeof PostKycMockApproveUnauthorizedError
->;
-
 /**
  * Response
  */
@@ -171,16 +157,6 @@ export function postKycMockApproveRequestToJSON(
   );
 }
 
-/** @internal */
-export const PostKycMockApproveNotFoundError$inboundSchema: z.ZodMiniEnum<
-  typeof PostKycMockApproveNotFoundError
-> = z.enum(PostKycMockApproveNotFoundError);
-
-/** @internal */
-export const PostKycMockApproveUnauthorizedError$inboundSchema: z.ZodMiniEnum<
-  typeof PostKycMockApproveUnauthorizedError
-> = z.enum(PostKycMockApproveUnauthorizedError);
-
 /** @internal */
 export const PostKycMockApproveResponse$inboundSchema: z.ZodMiniType<
   PostKycMockApproveResponse,

package/src/models/operations/post-kyc-mock-reject.ts

@@ -4,7 +4,6 @@
 
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
@@ -16,20 +15,6 @@ export type PostKycMockRejectRequest = {
   reason?: string | undefined;
 };
 
-export const PostKycMockRejectNotFoundError = {
-  NotFound: "not_found",
-} as const;
-export type PostKycMockRejectNotFoundError = ClosedEnum<
-  typeof PostKycMockRejectNotFoundError
->;
-
-export const PostKycMockRejectUnauthorizedError = {
-  Unauthorized: "unauthorized",
-} as const;
-export type PostKycMockRejectUnauthorizedError = ClosedEnum<
-  typeof PostKycMockRejectUnauthorizedError
->;
-
 /**
  * Response
  */
@@ -73,16 +58,6 @@ export function postKycMockRejectRequestToJSON(
   );
 }
 
-/** @internal */
-export const PostKycMockRejectNotFoundError$inboundSchema: z.ZodMiniEnum<
-  typeof PostKycMockRejectNotFoundError
-> = z.enum(PostKycMockRejectNotFoundError);
-
-/** @internal */
-export const PostKycMockRejectUnauthorizedError$inboundSchema: z.ZodMiniEnum<
-  typeof PostKycMockRejectUnauthorizedError
-> = z.enum(PostKycMockRejectUnauthorizedError);
-
 /** @internal */
 export const PostKycMockRejectResponse$inboundSchema: z.ZodMiniType<
   PostKycMockRejectResponse,

package/src/models/operations/post-oauth-token.ts

@@ -10,6 +10,41 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
+export type PostOauthTokenRequest = {
+  /**
+   * Grant type: authorization_code or refresh_token
+   */
+  grantType: string;
+  /**
+   * Client application ID
+   */
+  clientId?: string | undefined;
+  /**
+   * Client secret for confidential clients
+   */
+  clientSecret?: string | undefined;
+  /**
+   * Authorization code (for authorization_code grant)
+   */
+  code?: string | undefined;
+  /**
+   * Redirect URI (must match original)
+   */
+  redirectUri?: string | undefined;
+  /**
+   * PKCE code verifier
+   */
+  codeVerifier?: string | undefined;
+  /**
+   * Refresh token (for refresh_token grant)
+   */
+  refreshToken?: string | undefined;
+  /**
+   * Requested scopes (can only narrow)
+   */
+  scope?: string | undefined;
+};
+
 /**
  * Token type
  */
@@ -53,6 +88,53 @@ export type PostOauthTokenResponse = {
   scope?: string | undefined;
 };
 
+/** @internal */
+export type PostOauthTokenRequest$Outbound = {
+  grant_type: string;
+  client_id?: string | undefined;
+  client_secret?: string | undefined;
+  code?: string | undefined;
+  redirect_uri?: string | undefined;
+  code_verifier?: string | undefined;
+  refresh_token?: string | undefined;
+  scope?: string | undefined;
+};
+
+/** @internal */
+export const PostOauthTokenRequest$outboundSchema: z.ZodMiniType<
+  PostOauthTokenRequest$Outbound,
+  PostOauthTokenRequest
+> = z.pipe(
+  z.object({
+    grantType: z.string(),
+    clientId: z.optional(z.string()),
+    clientSecret: z.optional(z.string()),
+    code: z.optional(z.string()),
+    redirectUri: z.optional(z.string()),
+    codeVerifier: z.optional(z.string()),
+    refreshToken: z.optional(z.string()),
+    scope: z.optional(z.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      grantType: "grant_type",
+      clientId: "client_id",
+      clientSecret: "client_secret",
+      redirectUri: "redirect_uri",
+      codeVerifier: "code_verifier",
+      refreshToken: "refresh_token",
+    });
+  }),
+);
+
+export function postOauthTokenRequestToJSON(
+  postOauthTokenRequest: PostOauthTokenRequest,
+): string {
+  return JSON.stringify(
+    PostOauthTokenRequest$outboundSchema.parse(postOauthTokenRequest),
+  );
+}
+
 /** @internal */
 export const PostOauthTokenTokenType$inboundSchema: z.ZodMiniEnum<
   typeof PostOauthTokenTokenType

package/src/models/operations/post-orgs-by-org-id-api-keys-by-key-id-rotate.ts

@@ -0,0 +1,134 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+export type PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody = {
+  permissions?: Array<string> | undefined;
+};
+
+export type PostOrgsByOrgIdApiKeysByKeyIdRotateRequest = {
+  orgId: string;
+  keyId: string;
+  body: PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody;
+};
+
+/**
+ * Response
+ */
+export type PostOrgsByOrgIdApiKeysByKeyIdRotateResponse = {
+  id: string;
+  name: string;
+  /**
+   * The full API key -- shown only once
+   */
+  key: string;
+  keyPrefix?: string | null | undefined;
+  permissions?: Array<string> | null | undefined;
+  status?: string | null | undefined;
+  createdAt?: string | null | undefined;
+  /**
+   * ID of the predecessor key that was revoked
+   */
+  rotatedFrom: string;
+};
+
+/** @internal */
+export type PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody$Outbound = {
+  permissions?: Array<string> | undefined;
+};
+
+/** @internal */
+export const PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody$outboundSchema:
+  z.ZodMiniType<
+    PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody$Outbound,
+    PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody
+  > = z.object({
+    permissions: z.optional(z.array(z.string())),
+  });
+
+export function postOrgsByOrgIdApiKeysByKeyIdRotateRequestBodyToJSON(
+  postOrgsByOrgIdApiKeysByKeyIdRotateRequestBody:
+    PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody,
+): string {
+  return JSON.stringify(
+    PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody$outboundSchema.parse(
+      postOrgsByOrgIdApiKeysByKeyIdRotateRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type PostOrgsByOrgIdApiKeysByKeyIdRotateRequest$Outbound = {
+  orgId: string;
+  keyId: string;
+  body: PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody$Outbound;
+};
+
+/** @internal */
+export const PostOrgsByOrgIdApiKeysByKeyIdRotateRequest$outboundSchema:
+  z.ZodMiniType<
+    PostOrgsByOrgIdApiKeysByKeyIdRotateRequest$Outbound,
+    PostOrgsByOrgIdApiKeysByKeyIdRotateRequest
+  > = z.object({
+    orgId: z.string(),
+    keyId: z.string(),
+    body: z.lazy(() =>
+      PostOrgsByOrgIdApiKeysByKeyIdRotateRequestBody$outboundSchema
+    ),
+  });
+
+export function postOrgsByOrgIdApiKeysByKeyIdRotateRequestToJSON(
+  postOrgsByOrgIdApiKeysByKeyIdRotateRequest:
+    PostOrgsByOrgIdApiKeysByKeyIdRotateRequest,
+): string {
+  return JSON.stringify(
+    PostOrgsByOrgIdApiKeysByKeyIdRotateRequest$outboundSchema.parse(
+      postOrgsByOrgIdApiKeysByKeyIdRotateRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const PostOrgsByOrgIdApiKeysByKeyIdRotateResponse$inboundSchema:
+  z.ZodMiniType<PostOrgsByOrgIdApiKeysByKeyIdRotateResponse, unknown> = z.pipe(
+    z.object({
+      id: types.string(),
+      name: types.string(),
+      key: types.string(),
+      key_prefix: z.optional(z.nullable(types.string())),
+      permissions: z.optional(z.nullable(z.array(types.string()))),
+      status: z.optional(z.nullable(types.string())),
+      created_at: z.optional(z.nullable(types.string())),
+      rotated_from: types.string(),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "key_prefix": "keyPrefix",
+        "created_at": "createdAt",
+        "rotated_from": "rotatedFrom",
+      });
+    }),
+  );
+
+export function postOrgsByOrgIdApiKeysByKeyIdRotateResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PostOrgsByOrgIdApiKeysByKeyIdRotateResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PostOrgsByOrgIdApiKeysByKeyIdRotateResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PostOrgsByOrgIdApiKeysByKeyIdRotateResponse' from JSON`,
+  );
+}

package/src/models/operations/post-orgs-by-org-id-assets-by-asset-id-allocate.ts

@@ -42,7 +42,7 @@ export type PostOrgsByOrgIdAssetsByAssetIdAllocateRequest = {
   body: PostOrgsByOrgIdAssetsByAssetIdAllocateRequestBody;
 };
 
-export type PostOrgsByOrgIdAssetsByAssetIdAllocateError = {
+export type ErrorT = {
   userId: string;
   error: string;
 };
@@ -54,7 +54,7 @@ export type PostOrgsByOrgIdAssetsByAssetIdAllocateResponse = {
   accepted: boolean;
   transferIds: Array<string>;
   requestId: string;
-  errors?: Array<PostOrgsByOrgIdAssetsByAssetIdAllocateError> | undefined;
+  errors?: Array<ErrorT> | undefined;
 };
 
 /** @internal */
@@ -164,26 +164,18 @@ export function postOrgsByOrgIdAssetsByAssetIdAllocateRequestToJSON(
 }
 
 /** @internal */
-export const PostOrgsByOrgIdAssetsByAssetIdAllocateError$inboundSchema:
-  z.ZodMiniType<PostOrgsByOrgIdAssetsByAssetIdAllocateError, unknown> = z
-    .object({
-      userId: types.string(),
-      error: types.string(),
-    });
+export const ErrorT$inboundSchema: z.ZodMiniType<ErrorT, unknown> = z.object({
+  userId: types.string(),
+  error: types.string(),
+});
 
-export function postOrgsByOrgIdAssetsByAssetIdAllocateErrorFromJSON(
+export function errorFromJSON(
   jsonString: string,
-): SafeParseResult<
-  PostOrgsByOrgIdAssetsByAssetIdAllocateError,
-  SDKValidationError
-> {
+): SafeParseResult<ErrorT, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) =>
-      PostOrgsByOrgIdAssetsByAssetIdAllocateError$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'PostOrgsByOrgIdAssetsByAssetIdAllocateError' from JSON`,
+    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorT' from JSON`,
   );
 }
 
@@ -194,11 +186,7 @@ export const PostOrgsByOrgIdAssetsByAssetIdAllocateResponse$inboundSchema:
       accepted: types.boolean(),
       transferIds: z.array(types.string()),
       requestId: types.string(),
-      errors: types.optional(
-        z.array(z.lazy(() =>
-          PostOrgsByOrgIdAssetsByAssetIdAllocateError$inboundSchema
-        )),
-      ),
+      errors: types.optional(z.array(z.lazy(() => ErrorT$inboundSchema))),
     });
 
 export function postOrgsByOrgIdAssetsByAssetIdAllocateResponseFromJSON(

package/src/models/operations/post-orgs-by-org-id-invite-eligibility.ts

@@ -27,13 +27,6 @@ export type PostOrgsByOrgIdInviteEligibilityRequest = {
   body: PostOrgsByOrgIdInviteEligibilityRequestBody;
 };
 
-export const PostOrgsByOrgIdInviteEligibilityError = {
-  Forbidden: "forbidden",
-} as const;
-export type PostOrgsByOrgIdInviteEligibilityError = ClosedEnum<
-  typeof PostOrgsByOrgIdInviteEligibilityError
->;
-
 export const CodeRegSUsRestriction = {
   RegSUsRestriction: "REG_S_US_RESTRICTION",
 } as const;
@@ -204,11 +197,6 @@ export function postOrgsByOrgIdInviteEligibilityRequestToJSON(
   );
 }
 
-/** @internal */
-export const PostOrgsByOrgIdInviteEligibilityError$inboundSchema: z.ZodMiniEnum<
-  typeof PostOrgsByOrgIdInviteEligibilityError
-> = z.enum(PostOrgsByOrgIdInviteEligibilityError);
-
 /** @internal */
 export const CodeRegSUsRestriction$inboundSchema: z.ZodMiniEnum<
   typeof CodeRegSUsRestriction

package/src/models/operations/post-orgs-by-org-id-members-by-user-id-attest.ts

@@ -47,27 +47,6 @@ export type PostOrgsByOrgIdMembersByUserIdAttestRequest = {
   body: PostOrgsByOrgIdMembersByUserIdAttestRequestBody;
 };
 
-export const PostOrgsByOrgIdMembersByUserIdAttestNotFoundError = {
-  NotFound: "not_found",
-} as const;
-export type PostOrgsByOrgIdMembersByUserIdAttestNotFoundError = ClosedEnum<
-  typeof PostOrgsByOrgIdMembersByUserIdAttestNotFoundError
->;
-
-export const PostOrgsByOrgIdMembersByUserIdAttestForbiddenError = {
-  Forbidden: "forbidden",
-} as const;
-export type PostOrgsByOrgIdMembersByUserIdAttestForbiddenError = ClosedEnum<
-  typeof PostOrgsByOrgIdMembersByUserIdAttestForbiddenError
->;
-
-export const PostOrgsByOrgIdMembersByUserIdAttestUnauthorizedError = {
-  Unauthorized: "unauthorized",
-} as const;
-export type PostOrgsByOrgIdMembersByUserIdAttestUnauthorizedError = ClosedEnum<
-  typeof PostOrgsByOrgIdMembersByUserIdAttestUnauthorizedError
->;
-
 export const PostOrgsByOrgIdMembersByUserIdAttestStatus = {
   Pending: "pending",
 } as const;
@@ -184,21 +163,6 @@ export function postOrgsByOrgIdMembersByUserIdAttestRequestToJSON(
   );
 }
 
-/** @internal */
-export const PostOrgsByOrgIdMembersByUserIdAttestNotFoundError$inboundSchema:
-  z.ZodMiniEnum<typeof PostOrgsByOrgIdMembersByUserIdAttestNotFoundError> = z
-    .enum(PostOrgsByOrgIdMembersByUserIdAttestNotFoundError);
-
-/** @internal */
-export const PostOrgsByOrgIdMembersByUserIdAttestForbiddenError$inboundSchema:
-  z.ZodMiniEnum<typeof PostOrgsByOrgIdMembersByUserIdAttestForbiddenError> = z
-    .enum(PostOrgsByOrgIdMembersByUserIdAttestForbiddenError);
-
-/** @internal */
-export const PostOrgsByOrgIdMembersByUserIdAttestUnauthorizedError$inboundSchema:
-  z.ZodMiniEnum<typeof PostOrgsByOrgIdMembersByUserIdAttestUnauthorizedError> =
-    z.enum(PostOrgsByOrgIdMembersByUserIdAttestUnauthorizedError);
-
 /** @internal */
 export const PostOrgsByOrgIdMembersByUserIdAttestStatus$inboundSchema:
   z.ZodMiniEnum<typeof PostOrgsByOrgIdMembersByUserIdAttestStatus> = z.enum(