export const tools = [
  {
    description:
      "The Clerk interstitial endpoint serves an html page that loads clerk.js in order to check the user's authentication state.\nIt is used by Clerk SDKs when the user's authentication state cannot be immediately determined.",
    method: "get",
    name: "GetPublicInterstitial",
    url: "https://api.clerk.com/v1/public/interstitial",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        deprecated: true,
        description: "Please use `frontend_api` instead",
        in: "query",
        name: "frontendApi",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "The Frontend API key of your instance",
        in: "query",
        name: "frontend_api",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "The publishable key of your instance",
        in: "query",
        name: "publishable_key",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "The proxy URL of your instance",
        in: "query",
        name: "proxy_url",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "The domain of your instance",
        in: "query",
        name: "domain",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "The sign in URL of your instance",
        in: "query",
        name: "sign_in_url",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "Whether to use the domain for the script URL",
        in: "query",
        name: "use_domain_for_script",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description: "Retrieve the JSON Web Key Set of the instance",
    method: "get",
    name: "GetJWKS",
    url: "https://api.clerk.com/v1/jwks",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    defs: {},
  },
  {
    description:
      "Returns a list of all clients. The clients are returned sorted by creation date,\nwith the newest clients appearing first.\nWarning: the endpoint is being deprecated and will be removed in future versions.",
    method: "get",
    name: "GetClientList",
    url: "https://api.clerk.com/v1/clients",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Whether to paginate the results.\nIf true, the results will be paginated.\nIf false, the results will not be paginated.",
        in: "query",
        name: "paginated",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description: "Verifies the client in the provided token",
    method: "post",
    name: "VerifyClient",
    url: "https://api.clerk.com/v1/clients/verify",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["token"],
      type: "object",
      additionalProperties: false,
      properties: {
        token: {
          description: "A JWT that represents the active client.",
          type: "string",
        },
      },
      description: "Parameters.",
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Returns the details of a client.",
    method: "get",
    name: "GetClient",
    url: "https://api.clerk.com/v1/clients/{client_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "Client ID.",
        in: "path",
        name: "client_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Create a new email address",
    method: "post",
    name: "CreateEmailAddress",
    url: "https://api.clerk.com/v1/email_addresses",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["user_id", "email_address"],
      type: "object",
      properties: {
        user_id: {
          description: "The ID representing the user",
          type: "string",
        },
        email_address: {
          description:
            "The new email address. Must adhere to the RFC 5322 specification for email address format.",
          type: "string",
        },
        verified: {
          description:
            "When created, the email address will be marked as verified.",
          type: ["boolean", "null"],
        },
        primary: {
          description:
            "Create this email address as the primary email address for the user.\nDefault: false, unless it is the first email address.",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Returns the details of an email address.",
    method: "get",
    name: "GetEmailAddress",
    url: "https://api.clerk.com/v1/email_addresses/{email_address_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the email address to retrieve",
        in: "path",
        name: "email_address_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Delete the email address with the given ID",
    method: "delete",
    name: "DeleteEmailAddress",
    url: "https://api.clerk.com/v1/email_addresses/{email_address_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the email address to delete",
        in: "path",
        name: "email_address_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Updates an email address.",
    method: "patch",
    name: "UpdateEmailAddress",
    url: "https://api.clerk.com/v1/email_addresses/{email_address_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the email address to update",
        in: "path",
        name: "email_address_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      properties: {
        verified: {
          description: "The email address will be marked as verified.",
          type: ["boolean", "null"],
        },
        primary: {
          description:
            "Set this email address as the primary email address for the user.",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Create a new phone number",
    method: "post",
    name: "CreatePhoneNumber",
    url: "https://api.clerk.com/v1/phone_numbers",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["user_id", "phone_number"],
      type: "object",
      properties: {
        user_id: {
          description: "The ID representing the user",
          type: "string",
        },
        phone_number: {
          description:
            "The new phone number. Must adhere to the E.164 standard for phone number format.",
          type: "string",
        },
        verified: {
          description:
            "When created, the phone number will be marked as verified.",
          type: ["boolean", "null"],
        },
        primary: {
          description:
            "Create this phone number as the primary phone number for the user. Default: false, unless it is the first phone number.",
          type: ["boolean", "null"],
        },
        reserved_for_second_factor: {
          description:
            "Create this phone number as reserved for multi-factor authentication. The phone number must also be verified.\nIf there are no other reserved second factors, the phone number will be set as the default second factor.",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Returns the details of a phone number",
    method: "get",
    name: "GetPhoneNumber",
    url: "https://api.clerk.com/v1/phone_numbers/{phone_number_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the phone number to retrieve",
        in: "path",
        name: "phone_number_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Delete the phone number with the given ID",
    method: "delete",
    name: "DeletePhoneNumber",
    url: "https://api.clerk.com/v1/phone_numbers/{phone_number_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the phone number to delete",
        in: "path",
        name: "phone_number_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Updates a phone number",
    method: "patch",
    name: "UpdatePhoneNumber",
    url: "https://api.clerk.com/v1/phone_numbers/{phone_number_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the phone number to update",
        in: "path",
        name: "phone_number_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      properties: {
        verified: {
          description: "The phone number will be marked as verified.",
          type: ["boolean", "null"],
        },
        primary: {
          description:
            "Set this phone number as the primary phone number for the user.",
          type: ["boolean", "null"],
        },
        reserved_for_second_factor: {
          description:
            "Set this phone number as reserved for multi-factor authentication.\nThe phone number must also be verified.\nIf there are no other reserved second factors, the phone number will be set as the default second factor.",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Returns a list of all sessions.\nThe sessions are returned sorted by creation date, with the newest sessions appearing first.\n**Deprecation Notice (2024-01-01):** All parameters were initially considered optional, however\nmoving forward at least one of `client_id` or `user_id` parameters should be provided.",
    method: "get",
    name: "GetSessionList",
    url: "https://api.clerk.com/v1/sessions",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "List sessions for the given client",
        in: "query",
        name: "client_id",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "List sessions for the given user",
        in: "query",
        name: "user_id",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "Filter sessions by the provided status",
        in: "query",
        name: "status",
        required: false,
        explode: true,
        schema: {
          enum: [
            "abandoned",
            "active",
            "ended",
            "expired",
            "removed",
            "replaced",
            "revoked",
          ],
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Whether to paginate the results.\nIf true, the results will be paginated.\nIf false, the results will not be paginated.",
        in: "query",
        name: "paginated",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Create a new active session for the provided user ID.\n\n**This operation is intended only for use in testing, and is not available for production instances.** If you are looking to generate a user session from the backend,\nwe recommend using the [Sign-in Tokens](https://clerk.com/docs/reference/backend-api/tag/Sign-in-Tokens#operation/CreateSignInToken) resource instead.",
    method: "post",
    name: "createSession",
    url: "https://api.clerk.com/v1/sessions",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["user_id"],
      type: "object",
      properties: {
        user_id: {
          description: "The ID representing the user",
          type: "string",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Retrieve the details of a session",
    method: "get",
    name: "GetSession",
    url: "https://api.clerk.com/v1/sessions/{session_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the session",
        in: "path",
        name: "session_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      'Sets the status of a session as "revoked", which is an unauthenticated state.\nIn multi-session mode, a revoked session will still be returned along with its client object, however the user will need to sign in again.',
    method: "post",
    name: "RevokeSession",
    url: "https://api.clerk.com/v1/sessions/{session_id}/revoke",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the session",
        in: "path",
        name: "session_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Returns the session if it is authenticated, otherwise returns an error.\nWARNING: This endpoint is deprecated and will be removed in future versions. We strongly recommend switching to networkless verification using short-lived session tokens,\n         which is implemented transparently in all recent SDK versions (e.g. [NodeJS SDK](https://clerk.com/docs/backend-requests/handling/nodejs#clerk-express-require-auth)).\n         For more details on how networkless verification works, refer to our [Session Tokens documentation](https://clerk.com/docs/backend-requests/resources/session-tokens).",
    method: "post",
    name: "VerifySession",
    url: "https://api.clerk.com/v1/sessions/{session_id}/verify",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the session",
        in: "path",
        name: "session_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        token: {
          description:
            "The JWT that is sent via the `__session` cookie from your frontend.\nNote: this JWT must be associated with the supplied session ID.",
          type: "string",
        },
      },
      description: "Parameters.",
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Creates a session JSON Web Token (JWT) based on a session.",
    method: "post",
    name: "CreateSessionToken",
    url: "https://api.clerk.com/v1/sessions/{session_id}/tokens",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the session",
        in: "path",
        name: "session_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      properties: {
        expires_in_seconds: {
          description:
            "Use this parameter to override the default session token lifetime.",
          maximum: 315360000,
          minimum: 30,
          type: ["number", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Creates a JSON Web Token(JWT) based on a session and a JWT Template name defined for your instance",
    method: "post",
    name: "CreateSessionTokenFromTemplate",
    url: "https://api.clerk.com/v1/sessions/{session_id}/tokens/{template_name}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the session",
        in: "path",
        name: "session_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          "The name of the JWT Template defined in your instance (e.g. `custom_hasura`).",
        in: "path",
        name: "template_name",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      properties: {
        expires_in_seconds: {
          description: "Use this parameter to override the JWT token lifetime.",
          maximum: 315360000,
          minimum: 30,
          type: ["number", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Returns a list of all templates.\nThe templates are returned sorted by position.",
    method: "get",
    name: "GetTemplateList",
    url: "https://api.clerk.com/v1/templates/{template_type}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The type of templates to list (email or SMS)",
        in: "path",
        name: "template_type",
        required: true,
        explode: false,
        schema: {
          enum: ["email", "sms"],
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          "Whether to paginate the results.\nIf true, the results will be paginated.\nIf false, the results will not be paginated.",
        in: "query",
        name: "paginated",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description: "Returns the details of a template",
    method: "get",
    name: "GetTemplate",
    url: "https://api.clerk.com/v1/templates/{template_type}/{slug}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The type of templates to retrieve (email or SMS)",
        in: "path",
        name: "template_type",
        required: true,
        explode: false,
        schema: {
          enum: ["email", "sms"],
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          "The slug (i.e. machine-friendly name) of the template to retrieve",
        in: "path",
        name: "slug",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Updates the existing template of the given type and slug",
    method: "put",
    name: "UpsertTemplate",
    url: "https://api.clerk.com/v1/templates/{template_type}/{slug}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The type of template to update",
        in: "path",
        name: "template_type",
        required: true,
        explode: false,
        schema: {
          enum: ["email", "sms"],
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The slug of the template to update",
        in: "path",
        name: "slug",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        name: {
          description: "The user-friendly name of the template",
          type: "string",
        },
        subject: {
          description:
            "The email subject.\nApplicable only to email templates.",
          type: ["string", "null"],
        },
        markup: {
          description:
            "The editor markup used to generate the body of the template",
          type: ["string", "null"],
        },
        body: {
          description: "The template body before variable interpolation",
          type: "string",
        },
        delivered_by_clerk: {
          description:
            "Whether Clerk should deliver emails or SMS messages based on the current template",
          type: ["boolean", "null"],
        },
        from_email_name: {
          description:
            "The local part of the From email address that will be used for emails.\nFor example, in the address 'hello@example.com', the local part is 'hello'.\nApplicable only to email templates.",
          type: "string",
        },
        reply_to_email_name: {
          description:
            "The local part of the Reply To email address that will be used for emails.\nFor example, in the address 'hello@example.com', the local part is 'hello'.\nApplicable only to email templates.",
          type: "string",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Reverts an updated template to its default state",
    method: "post",
    name: "RevertTemplate",
    url: "https://api.clerk.com/v1/templates/{template_type}/{slug}/revert",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The type of template to revert",
        in: "path",
        name: "template_type",
        required: true,
        explode: false,
        schema: {
          enum: ["email", "sms"],
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The slug of the template to revert",
        in: "path",
        name: "slug",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Returns a preview of a template for a given template_type, slug and body",
    method: "post",
    name: "PreviewTemplate",
    url: "https://api.clerk.com/v1/templates/{template_type}/{slug}/preview",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The type of template to preview",
        in: "path",
        name: "template_type",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The slug of the template to preview",
        in: "path",
        name: "slug",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        subject: {
          description:
            "The email subject.\nApplicable only to email templates.",
          type: ["string", "null"],
        },
        body: {
          description: "The template body before variable interpolation",
          type: "string",
        },
        from_email_name: {
          description:
            "The local part of the From email address that will be used for emails.\nFor example, in the address 'hello@example.com', the local part is 'hello'.\nApplicable only to email templates.",
          type: "string",
        },
        reply_to_email_name: {
          description:
            "The local part of the Reply To email address that will be used for emails.\nFor example, in the address 'hello@example.com', the local part is 'hello'.\nApplicable only to email templates.",
          type: "string",
        },
      },
      description: "Required parameters",
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Toggles the delivery by Clerk for a template of a given type and slug.\nIf disabled, Clerk will not deliver the resulting email or SMS.\nThe app developer will need to listen to the `email.created` or `sms.created` webhooks in order to handle delivery themselves.",
    method: "post",
    name: "ToggleTemplateDelivery",
    url: "https://api.clerk.com/v1/templates/{template_type}/{slug}/toggle_delivery",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The type of template to toggle delivery for",
        in: "path",
        name: "template_type",
        required: true,
        explode: false,
        schema: {
          enum: ["email", "sms"],
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The slug of the template for which to toggle delivery",
        in: "path",
        name: "slug",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        delivered_by_clerk: {
          description:
            "Whether Clerk should deliver emails or SMS messages based on the current template",
          type: "boolean",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Returns a list of all users.\nThe users are returned sorted by creation date, with the newest users appearing first.",
    method: "get",
    name: "GetUserList",
    url: "https://api.clerk.com/v1/users",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Returns users with the specified email addresses.\nAccepts up to 100 email addresses.\nAny email addresses not found are ignored.",
        in: "query",
        name: "email_address",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the specified phone numbers.\nAccepts up to 100 phone numbers.\nAny phone numbers not found are ignored.",
        in: "query",
        name: "phone_number",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the specified external ids.\nFor each external id, the `+` and `-` can be\nprepended to the id, which denote whether the\nrespective external id should be included or\nexcluded from the result set.\nAccepts up to 100 external ids.\nAny external ids not found are ignored.",
        in: "query",
        name: "external_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the specified usernames.\nAccepts up to 100 usernames.\nAny usernames not found are ignored.",
        in: "query",
        name: "username",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the specified web3 wallet addresses.\nAccepts up to 100 web3 wallet addresses.\nAny web3 wallet addressed not found are ignored.",
        in: "query",
        name: "web3_wallet",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the user ids specified.\nFor each user id, the `+` and `-` can be\nprepended to the id, which denote whether the\nrespective user id should be included or\nexcluded from the result set.\nAccepts up to 100 user ids.\nAny user ids not found are ignored.",
        in: "query",
        name: "user_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users that have memberships to the\ngiven organizations.\nFor each organization id, the `+` and `-` can be\nprepended to the id, which denote whether the\nrespective organization should be included or\nexcluded from the result set.\nAccepts up to 100 organization ids.",
        in: "query",
        name: "organization_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users that match the given query.\nFor possible matches, we check the email addresses, phone numbers, usernames, web3 wallets, user ids, first and last names.\nThe query value doesn't need to match the exact value you are looking for, it is capable of partial matches as well.",
        in: "query",
        name: "query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with emails that match the given query, via case-insensitive partial match.\nFor example, `email_address_query=ello` will match a user with the email `HELLO@example.com`.",
        in: "query",
        name: "email_address_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with phone numbers that match the given query, via case-insensitive partial match.\nFor example, `phone_number_query=555` will match a user with the phone number `+1555xxxxxxx`.",
        in: "query",
        name: "phone_number_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with usernames that match the given query, via case-insensitive partial match.\nFor example, `username_query=CoolUser` will match a user with the username `SomeCoolUser`.",
        in: "query",
        name: "username_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with names that match the given query, via case-insensitive partial match.",
        in: "query",
        name: "name_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users which are either banned (`banned=true`) or not banned (`banned=false`).",
        in: "query",
        name: "banned",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Returns users whose last session activity was before the given date (with millisecond precision).\nExample: use 1700690400000 to retrieve users whose last session activity was before 2023-11-23.",
        in: "query",
        name: "last_active_at_before",
        required: false,
        example: 1700690400000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns users whose last session activity was after the given date (with millisecond precision).\nExample: use 1700690400000 to retrieve users whose last session activity was after 2023-11-23.",
        in: "query",
        name: "last_active_at_after",
        required: false,
        example: 1700690400000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        deprecated: true,
        description:
          "Returns users that had session activity since the given date.\nExample: use 1700690400000 to retrieve users that had session activity from 2023-11-23 until the current day.\nDeprecated in favor of `last_active_at_after`.",
        in: "query",
        name: "last_active_at_since",
        required: false,
        example: 1700690400000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns users who have been created before the given date (with millisecond precision).\nExample: use 1730160000000 to retrieve users who have been created before 2024-10-29.",
        in: "query",
        name: "created_at_before",
        required: false,
        example: 1730160000000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns users who have been created after the given date (with millisecond precision).\nExample: use 1730160000000 to retrieve users who have been created after 2024-10-29.",
        in: "query",
        name: "created_at_after",
        required: false,
        example: 1730160000000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Allows to return users in a particular order.\nAt the moment, you can order the returned users by their `created_at`,`updated_at`,`email_address`,`web3wallet`,`first_name`,`last_name`,`phone_number`,`username`,`last_active_at`,`last_sign_in_at`.\nIn order to specify the direction, you can use the `+/-` symbols prepended in the property to order by.\nFor example, if you want users to be returned in descending order according to their `created_at` property, you can use `-created_at`.\nIf you don't use `+` or `-`, then `+` is implied. We only support one `order_by` parameter, and if multiple `order_by` parameters are provided, we will only keep the first one. For example,\nif you pass `order_by=username&order_by=created_at`, we will consider only the first `order_by` parameter, which is `username`. The `created_at` parameter will be ignored in this case.",
        in: "query",
        name: "order_by",
        required: false,
        explode: true,
        schema: {
          default: "-created_at",
          type: "string",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Creates a new user. Your user management settings determine how you should setup your user model.\n\nAny email address and phone number created using this method will be marked as verified.\n\nNote: If you are performing a migration, check out our guide on [zero downtime migrations](https://clerk.com/docs/deployments/migrate-overview).\n\nA rate limit rule of 20 requests per 10 seconds is applied to this endpoint.",
    method: "post",
    name: "CreateUser",
    url: "https://api.clerk.com/v1/users",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        external_id: {
          description:
            "The ID of the user as used in your external systems or your previous authentication solution.\nMust be unique across your instance.",
          type: ["string", "null"],
        },
        first_name: {
          description: "The first name to assign to the user",
          type: ["string", "null"],
        },
        last_name: {
          description: "The last name to assign to the user",
          type: ["string", "null"],
        },
        email_address: {
          description:
            "Email addresses to add to the user.\nMust be unique across your instance.\nThe first email address will be set as the user's primary email address.",
          type: "array",
          items: {
            type: "string",
          },
        },
        phone_number: {
          description:
            "Phone numbers to add to the user.\nMust be unique across your instance.\nThe first phone number will be set as the user's primary phone number.",
          type: "array",
          items: {
            type: "string",
          },
        },
        web3_wallet: {
          description:
            "Web3 wallets to add to the user.\nMust be unique across your instance.\nThe first wallet will be set as the user's primary wallet.",
          type: "array",
          items: {
            type: "string",
          },
        },
        username: {
          description:
            "The username to give to the user.\nIt must be unique across your instance.",
          type: ["string", "null"],
        },
        password: {
          description:
            "The plaintext password to give the user.\nMust be at least 8 characters long, and can not be in any list of hacked passwords.",
          type: ["string", "null"],
        },
        password_digest: {
          description:
            "In case you already have the password digests and not the passwords, you can use them for the newly created user via this property.\nThe digests should be generated with one of the supported algorithms.\nThe hashing algorithm can be specified using the `password_hasher` property.",
          type: ["string", "null"],
        },
        password_hasher: {
          $ref: "#/$defs/PasswordHasher",
        },
        skip_password_checks: {
          description:
            "When set to `true` all password checks are skipped.\nIt is recommended to use this method only when migrating plaintext passwords to Clerk.\nUpon migration the user base should be prompted to pick stronger password.",
          type: ["boolean", "null"],
        },
        skip_password_requirement: {
          description:
            "When set to `true`, `password` is not required anymore when creating the user and can be omitted.\nThis is useful when you are trying to create a user that doesn't have a password, in an instance that is using passwords.\nPlease note that you cannot use this flag if password is the only way for a user to sign into your instance.",
          type: ["boolean", "null"],
        },
        totp_secret: {
          description:
            "In case TOTP is configured on the instance, you can provide the secret to enable it on the newly created user without the need to reset it.\nPlease note that currently the supported options are:\n* Period: 30 seconds\n* Code length: 6 digits\n* Algorithm: SHA1",
          type: ["string", "null"],
        },
        backup_codes: {
          description:
            "If Backup Codes are configured on the instance, you can provide them to enable it on the newly created user without the need to reset them.\nYou must provide the backup codes in plain format or the corresponding bcrypt digest.",
          type: "array",
          items: {
            type: "string",
          },
        },
        public_metadata: {
          description:
            "Metadata saved on the user, that is visible to both your Frontend and Backend APIs",
          type: "object",
          additionalProperties: true,
        },
        private_metadata: {
          description:
            "Metadata saved on the user, that is only visible to your Backend API",
          type: "object",
          additionalProperties: true,
        },
        unsafe_metadata: {
          description:
            "Metadata saved on the user, that can be updated from both the Frontend and Backend APIs.\nNote: Since this data can be modified from the frontend, it is not guaranteed to be safe.",
          type: "object",
          additionalProperties: true,
        },
        delete_self_enabled: {
          description: "If enabled, user can delete themselves via FAPI.\n",
          type: ["boolean", "null"],
        },
        legal_accepted_at: {
          description:
            "A custom timestamp denoting _when_ the user accepted legal requirements, specified in RFC3339 format (e.g. `2012-10-20T07:15:20.902Z`).",
          type: ["string", "null"],
        },
        skip_legal_checks: {
          description:
            "When set to `true` all legal checks are skipped.\nIt is not recommended to skip legal checks unless you are migrating a user to Clerk.",
          type: ["boolean", "null"],
        },
        create_organization_enabled: {
          description: "If enabled, user can create organizations via FAPI.\n",
          type: ["boolean", "null"],
        },
        create_organizations_limit: {
          description:
            "The maximum number of organizations the user can create. 0 means unlimited.\n",
          type: ["integer", "null"],
        },
        created_at: {
          description:
            "A custom date/time denoting _when_ the user signed up to the application, specified in RFC3339 format (e.g. `2012-10-20T07:15:20.902Z`).",
          type: ["string", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {
      PasswordHasher: {
        description:
          "The hashing algorithm that was used to generate the password digest.\n\nThe algorithms we support at the moment are [`bcrypt`](https://en.wikipedia.org/wiki/Bcrypt), [`bcrypt_sha256_django`](https://docs.djangoproject.com/en/4.0/topics/auth/passwords/), [`md5`](https://en.wikipedia.org/wiki/MD5), `pbkdf2_sha1`, `pbkdf2_sha256`, [`pbkdf2_sha256_django`](https://docs.djangoproject.com/en/4.0/topics/auth/passwords/),\n[`phpass`](https://www.openwall.com/phpass/), [`scrypt_firebase`](https://firebaseopensource.com/projects/firebase/scrypt/),\n[`scrypt_werkzeug`](https://werkzeug.palletsprojects.com/en/3.0.x/utils/#werkzeug.security.generate_password_hash), [`sha256`](https://en.wikipedia.org/wiki/SHA-2),\nand the [`argon2`](https://argon2.online/) variants: `argon2i` and `argon2id`.\n\nEach of the supported hashers expects the incoming digest to be in a particular format. See the [Clerk docs](https://clerk.com/docs/references/backend/user/create-user) for more information.",
        type: "string",
      },
    },
  },
  {
    description:
      "Returns a total count of all users that match the given filtering criteria.",
    method: "get",
    name: "GetUsersCount",
    url: "https://api.clerk.com/v1/users/count",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Counts users with the specified email addresses.\nAccepts up to 100 email addresses.\nAny email addresses not found are ignored.",
        in: "query",
        name: "email_address",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Counts users with the specified phone numbers.\nAccepts up to 100 phone numbers.\nAny phone numbers not found are ignored.",
        in: "query",
        name: "phone_number",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Counts users with the specified external ids.\nAccepts up to 100 external ids.\nAny external ids not found are ignored.",
        in: "query",
        name: "external_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Counts users with the specified usernames.\nAccepts up to 100 usernames.\nAny usernames not found are ignored.",
        in: "query",
        name: "username",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Counts users with the specified web3 wallet addresses.\nAccepts up to 100 web3 wallet addresses.\nAny web3 wallet addressed not found are ignored.",
        in: "query",
        name: "web3_wallet",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Counts users with the user ids specified.\nAccepts up to 100 user ids.\nAny user ids not found are ignored.",
        in: "query",
        name: "user_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users that have memberships to the given organizations. For each organization id, the `+` and `-`\ncan be prepended to the id, which denote whether the respective organization should be included or\nexcluded from the result set. Accepts up to 100 organization ids.",
        in: "query",
        name: "organization_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Counts users that match the given query.\nFor possible matches, we check the email addresses, phone numbers, usernames, web3 wallets, user ids, first and last names.\nThe query value doesn't need to match the exact value you are looking for, it is capable of partial matches as well.",
        in: "query",
        name: "query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Counts users with emails that match the given query, via case-insensitive partial match.\nFor example, `email_address_query=ello` will match a user with the email `HELLO@example.com`,\nand will be included in the resulting count.",
        in: "query",
        name: "email_address_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Counts users with phone numbers that match the given query, via case-insensitive partial match.\nFor example, `phone_number_query=555` will match a user with the phone number `+1555xxxxxxx`,\nand will be included in the resulting count.",
        in: "query",
        name: "phone_number_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Counts users with usernames that match the given query, via case-insensitive partial match.\nFor example, `username_query=CoolUser` will match a user with the username `SomeCoolUser`,\nand will be included in the resulting count.",
        in: "query",
        name: "username_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with names that match the given query, via case-insensitive partial match.",
        in: "query",
        name: "name_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Counts users which are either banned (`banned=true`) or not banned (`banned=false`).",
        in: "query",
        name: "banned",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Returns users whose last session activity was before the given date (with millisecond precision).\nExample: use 1700690400000 to retrieve users whose last session activity was before 2023-11-23.",
        in: "query",
        name: "last_active_at_before",
        required: false,
        example: 1700690400000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns users whose last session activity was after the given date (with millisecond precision).\nExample: use 1700690400000 to retrieve users whose last session activity was after 2023-11-23.",
        in: "query",
        name: "last_active_at_after",
        required: false,
        example: 1700690400000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        deprecated: true,
        description:
          "Returns users that had session activity since the given date.\nExample: use 1700690400000 to retrieve users that had session activity from 2023-11-23 until the current day.\nDeprecated in favor of `last_active_at_after`.",
        in: "query",
        name: "last_active_at_since",
        required: false,
        example: 1700690400000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns users who have been created before the given date (with millisecond precision).\nExample: use 1730160000000 to retrieve users who have been created before 2024-10-29.",
        in: "query",
        name: "created_at_before",
        required: false,
        example: 1730160000000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns users who have been created after the given date (with millisecond precision).\nExample: use 1730160000000 to retrieve users who have been created after 2024-10-29.",
        in: "query",
        name: "created_at_after",
        required: false,
        example: 1730160000000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description: "Retrieve the details of a user",
    method: "get",
    name: "GetUser",
    url: "https://api.clerk.com/v1/users/{user_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user to retrieve",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Delete the specified user",
    method: "delete",
    name: "DeleteUser",
    url: "https://api.clerk.com/v1/users/{user_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user to delete",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Update a user's attributes.\n\nYou can set the user's primary contact identifiers (email address and phone numbers) by updating the `primary_email_address_id` and `primary_phone_number_id` attributes respectively.\nBoth IDs should correspond to verified identifications that belong to the user.\n\nYou can remove a user's username by setting the username attribute to null or the blank string \"\".\nThis is a destructive action; the identification will be deleted forever.\nUsernames can be removed only if they are optional in your instance settings and there's at least one other identifier which can be used for authentication.\n\nThis endpoint allows changing a user's password. When passing the `password` parameter directly you have two further options.\nYou can ignore the password policy checks for your instance by setting the `skip_password_checks` parameter to `true`.\nYou can also choose to sign the user out of all their active sessions on any device once the password is updated. Just set `sign_out_of_other_sessions` to `true`.",
    method: "patch",
    name: "UpdateUser",
    url: "https://api.clerk.com/v1/users/{user_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user to update",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        external_id: {
          description:
            "The ID of the user as used in your external systems or your previous authentication solution.\nMust be unique across your instance.",
          type: ["string", "null"],
        },
        first_name: {
          description: "The first name to assign to the user",
          type: ["string", "null"],
        },
        last_name: {
          description: "The last name to assign to the user",
          type: ["string", "null"],
        },
        primary_email_address_id: {
          description:
            "The ID of the email address to set as primary.\nIt must be verified, and present on the current user.",
          type: ["string", "null"],
        },
        notify_primary_email_address_changed: {
          default: false,
          description:
            "If set to `true`, the user will be notified that their primary email address has changed.\nBy default, no notification is sent.",
          type: ["boolean", "null"],
        },
        primary_phone_number_id: {
          description:
            "The ID of the phone number to set as primary.\nIt must be verified, and present on the current user.",
          type: ["string", "null"],
        },
        primary_web3_wallet_id: {
          description:
            "The ID of the web3 wallets to set as primary.\nIt must be verified, and present on the current user.",
          type: ["string", "null"],
        },
        username: {
          description:
            "The username to give to the user.\nIt must be unique across your instance.",
          type: ["string", "null"],
        },
        profile_image_id: {
          description: "The ID of the image to set as the user's profile image",
          type: ["string", "null"],
        },
        password: {
          description:
            "The plaintext password to give the user.\nMust be at least 8 characters long, and can not be in any list of hacked passwords.",
          type: ["string", "null"],
        },
        password_digest: {
          description:
            "In case you already have the password digests and not the passwords, you can use them for the newly created user via this property.\nThe digests should be generated with one of the supported algorithms.\nThe hashing algorithm can be specified using the `password_hasher` property.",
          type: "string",
        },
        password_hasher: {
          $ref: "#/$defs/PasswordHasher",
        },
        skip_password_checks: {
          description:
            "Set it to `true` if you're updating the user's password and want to skip any password policy settings check. This parameter can only be used when providing a `password`.",
          type: ["boolean", "null"],
        },
        sign_out_of_other_sessions: {
          description:
            "Set to `true` to sign out the user from all their active sessions once their password is updated. This parameter can only be used when providing a `password`.",
          type: ["boolean", "null"],
        },
        totp_secret: {
          description:
            "In case TOTP is configured on the instance, you can provide the secret to enable it on the specific user without the need to reset it.\nPlease note that currently the supported options are:\n* Period: 30 seconds\n* Code length: 6 digits\n* Algorithm: SHA1",
          type: ["string", "null"],
        },
        backup_codes: {
          description:
            "If Backup Codes are configured on the instance, you can provide them to enable it on the specific user without the need to reset them.\nYou must provide the backup codes in plain format or the corresponding bcrypt digest.",
          type: "array",
          items: {
            type: "string",
          },
        },
        public_metadata: {
          description:
            "Metadata saved on the user, that is visible to both your Frontend and Backend APIs",
          type: ["object", "null"],
          additionalProperties: true,
        },
        private_metadata: {
          description:
            "Metadata saved on the user, that is only visible to your Backend API",
          type: ["object", "null"],
          additionalProperties: true,
        },
        unsafe_metadata: {
          description:
            "Metadata saved on the user, that can be updated from both the Frontend and Backend APIs.\nNote: Since this data can be modified from the frontend, it is not guaranteed to be safe.",
          type: ["object", "null"],
          additionalProperties: true,
        },
        delete_self_enabled: {
          description:
            "If true, the user can delete themselves with the Frontend API.",
          type: ["boolean", "null"],
        },
        create_organization_enabled: {
          description:
            "If true, the user can create organizations with the Frontend API.",
          type: ["boolean", "null"],
        },
        legal_accepted_at: {
          description:
            "A custom timestamps denoting _when_ the user accepted legal requirements, specified in RFC3339 format (e.g. `2012-10-20T07:15:20.902Z`).",
          type: ["string", "null"],
        },
        skip_legal_checks: {
          description:
            "When set to `true` all legal checks are skipped.\nIt is not recommended to skip legal checks unless you are migrating a user to Clerk.",
          type: ["boolean", "null"],
        },
        create_organizations_limit: {
          description:
            "The maximum number of organizations the user can create. 0 means unlimited.",
          type: ["integer", "null"],
        },
        created_at: {
          description:
            "A custom date/time denoting _when_ the user signed up to the application, specified in RFC3339 format (e.g. `2012-10-20T07:15:20.902Z`).",
          type: ["string", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {
      PasswordHasher: {
        description:
          "The hashing algorithm that was used to generate the password digest.\n\nThe algorithms we support at the moment are [`bcrypt`](https://en.wikipedia.org/wiki/Bcrypt), [`bcrypt_sha256_django`](https://docs.djangoproject.com/en/4.0/topics/auth/passwords/), [`md5`](https://en.wikipedia.org/wiki/MD5), `pbkdf2_sha1`, `pbkdf2_sha256`, [`pbkdf2_sha256_django`](https://docs.djangoproject.com/en/4.0/topics/auth/passwords/),\n[`phpass`](https://www.openwall.com/phpass/), [`scrypt_firebase`](https://firebaseopensource.com/projects/firebase/scrypt/),\n[`scrypt_werkzeug`](https://werkzeug.palletsprojects.com/en/3.0.x/utils/#werkzeug.security.generate_password_hash), [`sha256`](https://en.wikipedia.org/wiki/SHA-2),\nand the [`argon2`](https://argon2.online/) variants: `argon2i` and `argon2id`.\n\nEach of the supported hashers expects the incoming digest to be in a particular format. See the [Clerk docs](https://clerk.com/docs/references/backend/user/create-user) for more information.",
        type: "string",
      },
    },
  },
  {
    description:
      "Marks the given user as banned, which means that all their sessions are revoked and they are not allowed to sign in again.",
    method: "post",
    name: "BanUser",
    url: "https://api.clerk.com/v1/users/{user_id}/ban",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user to ban",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Removes the ban mark from the given user.",
    method: "post",
    name: "UnbanUser",
    url: "https://api.clerk.com/v1/users/{user_id}/unban",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user to unban",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Marks the given user as locked, which means they are not allowed to sign in again until the lock expires.\nLock duration can be configured in the instance's restrictions settings.",
    method: "post",
    name: "LockUser",
    url: "https://api.clerk.com/v1/users/{user_id}/lock",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user to lock",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Removes the lock from the given user.",
    method: "post",
    name: "UnlockUser",
    url: "https://api.clerk.com/v1/users/{user_id}/unlock",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user to unlock",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Update a user's profile image",
    method: "post",
    name: "SetUserProfileImage",
    url: "https://api.clerk.com/v1/users/{user_id}/profile_image",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user to update the profile image for",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Delete a user's profile image",
    method: "delete",
    name: "DeleteUserProfileImage",
    url: "https://api.clerk.com/v1/users/{user_id}/profile_image",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user to delete the profile image for",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Update a user's metadata attributes by merging existing values with the provided parameters.\n\nThis endpoint behaves differently than the *Update a user* endpoint.\nMetadata values will not be replaced entirely.\nInstead, a deep merge will be performed.\nDeep means that any nested JSON objects will be merged as well.\n\nYou can remove metadata keys at any level by setting their value to `null`.",
    method: "patch",
    name: "UpdateUserMetadata",
    url: "https://api.clerk.com/v1/users/{user_id}/metadata",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the user whose metadata will be updated and merged",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        public_metadata: {
          description:
            "Metadata saved on the user, that is visible to both your frontend and backend.\nThe new object will be merged with the existing value.",
          type: "object",
          additionalProperties: true,
        },
        private_metadata: {
          description:
            "Metadata saved on the user that is only visible to your backend.\nThe new object will be merged with the existing value.",
          type: "object",
          additionalProperties: true,
        },
        unsafe_metadata: {
          description:
            "Metadata saved on the user, that can be updated from both the Frontend and Backend APIs.\nThe new object will be merged with the existing value.\n\nNote: Since this data can be modified from the frontend, it is not guaranteed to be safe.",
          type: "object",
          additionalProperties: true,
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Fetch the corresponding OAuth access token for a user that has previously authenticated with a particular OAuth provider.\nFor OAuth 2.0, if the access token has expired and we have a corresponding refresh token, the access token will be refreshed transparently the new one will be returned.",
    method: "get",
    name: "GetOAuthAccessToken",
    url: "https://api.clerk.com/v1/users/{user_id}/oauth_access_tokens/{provider}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the user for which to retrieve the OAuth access token",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The ID of the OAuth provider (e.g. `oauth_google`)",
        in: "path",
        name: "provider",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          "Whether to paginate the results.\nIf true, the results will be paginated.\nIf false, the results will not be paginated.",
        in: "query",
        name: "paginated",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Retrieve a paginated list of the user's organization memberships",
    method: "get",
    name: "UsersGetOrganizationMemberships",
    url: "https://api.clerk.com/v1/users/{user_id}/organization_memberships",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the user whose organization memberships we want to retrieve",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Retrieve a paginated list of the user's organization invitations",
    method: "get",
    name: "UsersGetOrganizationInvitations",
    url: "https://api.clerk.com/v1/users/{user_id}/organization_invitations",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the user whose organization invitations we want to retrieve",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
      {
        description: "Filter organization invitations based on their status",
        in: "query",
        name: "status",
        required: false,
        explode: true,
        schema: {
          enum: ["pending", "accepted", "revoked"],
          type: "string",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Check that the user's password matches the supplied input.\nUseful for custom auth flows and re-verification.",
    method: "post",
    name: "VerifyPassword",
    url: "https://api.clerk.com/v1/users/{user_id}/verify_password",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user for whom to verify the password",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      required: ["password"],
      type: "object",
      additionalProperties: false,
      properties: {
        password: {
          description: "The user password to verify",
          type: "string",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Verify that the provided TOTP or backup code is valid for the user.\nVerifying a backup code will result it in being consumed (i.e. it will\nbecome invalid).\nUseful for custom auth flows and re-verification.",
    method: "post",
    name: "VerifyTOTP",
    url: "https://api.clerk.com/v1/users/{user_id}/verify_totp",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user for whom to verify the TOTP",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      required: ["code"],
      type: "object",
      additionalProperties: false,
      properties: {
        code: {
          description: "The TOTP or backup code to verify",
          type: "string",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Disable all of a user's MFA methods (e.g. OTP sent via SMS, TOTP on their authenticator app) at once.",
    method: "delete",
    name: "DisableMFA",
    url: "https://api.clerk.com/v1/users/{user_id}/mfa",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user whose MFA methods are to be disabled",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Disable all of a user's backup codes.",
    method: "delete",
    name: "DeleteBackupCode",
    url: "https://api.clerk.com/v1/users/{user_id}/backup_code",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user whose backup codes are to be deleted.",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Delete the passkey identification for a given user and notify them through email.",
    method: "delete",
    name: "UserPasskeyDelete",
    url: "https://api.clerk.com/v1/users/{user_id}/passkeys/{passkey_identification_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user that owns the passkey identity",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The ID of the passkey identity to be deleted",
        in: "path",
        name: "passkey_identification_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Delete the web3 wallet identification for a given user.",
    method: "delete",
    name: "UserWeb3WalletDelete",
    url: "https://api.clerk.com/v1/users/{user_id}/web3_wallets/{web3_wallet_identification_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user that owns the web3 wallet",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The ID of the web3 wallet identity to be deleted",
        in: "path",
        name: "web3_wallet_identification_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Deletes all of the user's TOTPs.",
    method: "delete",
    name: "DeleteTOTP",
    url: "https://api.clerk.com/v1/users/{user_id}/totp",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user whose TOTPs are to be deleted",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Delete an external account by ID.",
    method: "delete",
    name: "DeleteExternalAccount",
    url: "https://api.clerk.com/v1/users/{user_id}/external_accounts/{external_account_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the user's external account",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The ID of the external account to delete",
        in: "path",
        name: "external_account_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Returns all non-revoked invitations for your application, sorted by creation date",
    method: "get",
    name: "ListInvitations",
    url: "https://api.clerk.com/v1/invitations",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "Filter invitations based on their status",
        in: "query",
        name: "status",
        required: false,
        explode: true,
        schema: {
          enum: ["pending", "accepted", "revoked", "expired"],
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Filter invitations based on their `email_address` or `id`",
        in: "query",
        name: "query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Allows to return organizations in a particular order.\nAt the moment, you can order the returned organizations either by their `name`, `created_at` or `members_count`.\nIn order to specify the direction, you can use the `+/-` symbols prepended in the property to order by.\nFor example, if you want organizations to be returned in descending order according to their `created_at` property, you can use `-created_at`.\nIf you don't use `+` or `-`, then `+` is implied.",
        in: "query",
        name: "order_by",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Whether to paginate the results.\nIf true, the results will be paginated.\nIf false, the results will not be paginated.",
        in: "query",
        name: "paginated",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Creates a new invitation for the given email address and sends the invitation email.\nKeep in mind that you cannot create an invitation if there is already one for the given email address.\nAlso, trying to create an invitation for an email address that already exists in your application will result to an error.",
    method: "post",
    name: "CreateInvitation",
    url: "https://api.clerk.com/v1/invitations",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["email_address"],
      type: "object",
      additionalProperties: false,
      properties: {
        email_address: {
          description: "The email address the invitation will be sent to",
          type: "string",
        },
        public_metadata: {
          description:
            "Metadata that will be attached to the newly created invitation.\nThe value of this property should be a well-formed JSON object.\nOnce the user accepts the invitation and signs up, these metadata will end up in the user's public metadata.",
          type: "object",
          additionalProperties: true,
        },
        redirect_url: {
          description:
            "Optional URL which specifies where to redirect the user once they click the invitation link.\nThis is only required if you have implemented a [custom flow](https://clerk.com/docs/authentication/invitations#custom-flow) and you're not using Clerk Hosted Pages or Clerk Components.",
          type: "string",
        },
        notify: {
          default: true,
          description:
            "Optional flag which denotes whether an email invitation should be sent to the given email address.\nDefaults to `true`.",
          type: ["boolean", "null"],
        },
        ignore_existing: {
          default: false,
          description:
            "Whether an invitation should be created if there is already an existing invitation for this email address, or it's claimed by another user.",
          type: ["boolean", "null"],
        },
        expires_in_days: {
          description:
            "The number of days the invitation will be valid for. By default, the invitation expires after 30 days.",
          maximum: 365,
          minimum: 1,
          type: ["integer", "null"],
        },
        template_slug: {
          description:
            "The slug of the email template to use for the invitation email.",
          enum: ["invitation", "waitlist_invitation"],
          type: "string",
        },
      },
      description: "Required parameters",
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Use this API operation to create multiple invitations for the provided email addresses. You can choose to send the\ninvitations as emails by setting the `notify` parameter to `true`. There cannot be an existing invitation for any\nof the email addresses you provide unless you set `ignore_existing` to `true` for specific email addresses. Please\nnote that there must be no existing user for any of the email addresses you provide, and this rule cannot be bypassed.",
    method: "post",
    name: "CreateBulkInvitations",
    url: "https://api.clerk.com/v1/invitations/bulk",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      type: "array",
      items: {
        required: ["email_address"],
        type: "object",
        additionalProperties: false,
        properties: {
          email_address: {
            description: "The email address the invitation will be sent to",
            type: "string",
          },
          public_metadata: {
            description:
              "Metadata that will be attached to the newly created invitation.\nThe value of this property should be a well-formed JSON object.\nOnce the user accepts the invitation and signs up, these metadata will end up in the user's public metadata.",
            type: ["object", "null"],
            additionalProperties: true,
          },
          redirect_url: {
            description:
              "The URL where the user is redirected upon visiting the invitation link, where they can accept the invitation. Required if you have implemented a [custom flow for handling application invitations](/docs/custom-flows/invitations).",
            type: ["string", "null"],
          },
          notify: {
            default: true,
            description:
              "Optional flag which denotes whether an email invitation should be sent to the given email address.\nDefaults to true.",
            type: ["boolean", "null"],
          },
          ignore_existing: {
            default: false,
            description:
              "Whether an invitation should be created if there is already an existing invitation for this email\naddress, or it's claimed by another user.",
            type: ["boolean", "null"],
          },
          expires_in_days: {
            description:
              "The number of days the invitation will be valid for. By default, the invitation expires after 30 days.",
            maximum: 365,
            minimum: 1,
            type: ["integer", "null"],
          },
          template_slug: {
            default: "invitation",
            description:
              "The slug of the email template to use for the invitation email.",
            enum: ["invitation", "waitlist_invitation"],
            type: "string",
          },
        },
      },
      description: "Required parameters",
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Revokes the given invitation.\nRevoking an invitation will prevent the user from using the invitation link that was sent to them.\nHowever, it doesn't prevent the user from signing up if they follow the sign up flow.\nOnly active (i.e. non-revoked) invitations can be revoked.",
    method: "post",
    name: "RevokeInvitation",
    url: "https://api.clerk.com/v1/invitations/{invitation_id}/revoke",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the invitation to be revoked",
        in: "path",
        name: "invitation_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "This request returns the list of organization invitations for the instance.\nResults can be paginated using the optional `limit` and `offset` query parameters.\nYou can filter them by providing the 'status' query parameter, that accepts multiple values.\nYou can change the order by providing the 'order' query parameter, that accepts multiple values.\nYou can filter by the invited user email address providing the `query` query parameter.\nThe organization invitations are ordered by descending creation date by default.",
    method: "get",
    name: "ListInstanceOrganizationInvitations",
    url: "https://api.clerk.com/v1/organization_invitations",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Allows to return organization invitations in a particular order.\nAt the moment, you can order the returned organization invitations either by their `created_at` or `email_address`.\nIn order to specify the direction, you can use the `+/-` symbols prepended in the property to order by.\nFor example, if you want organization invitations to be returned in descending order according to their `created_at` property, you can use `-created_at`.\nIf you don't use `+` or `-`, then `+` is implied.\nDefaults to `-created_at`.",
        in: "query",
        name: "order_by",
        required: false,
        explode: true,
        schema: {
          default: "-created_at",
          type: "string",
        },
        style: "form",
      },
      {
        description: "Filter organization invitations based on their status",
        in: "query",
        name: "status",
        required: false,
        explode: true,
        schema: {
          enum: ["pending", "accepted", "revoked"],
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Filter organization invitations based on their `email_address`",
        in: "query",
        name: "query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Get a list of all identifiers allowed to sign up to an instance",
    method: "get",
    name: "ListAllowlistIdentifiers",
    url: "https://api.clerk.com/v1/allowlist_identifiers",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Whether to paginate the results.\nIf true, the results will be paginated.\nIf false, the results will not be paginated.",
        in: "query",
        name: "paginated",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description: "Create an identifier allowed to sign up to an instance",
    method: "post",
    name: "CreateAllowlistIdentifier",
    url: "https://api.clerk.com/v1/allowlist_identifiers",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["identifier"],
      type: "object",
      additionalProperties: false,
      properties: {
        identifier: {
          description:
            "The identifier to be added in the allow-list.\nThis can be an email address, a phone number or a web3 wallet.",
          type: "string",
        },
        notify: {
          default: false,
          description:
            "This flag denotes whether the given identifier will receive an invitation to join the application.\nNote that this only works for email address and phone number identifiers.",
          type: "boolean",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Delete an identifier from the instance allow-list",
    method: "delete",
    name: "DeleteAllowlistIdentifier",
    url: "https://api.clerk.com/v1/allowlist_identifiers/{identifier_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the identifier to delete from the allow-list",
        in: "path",
        name: "identifier_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Get a list of all identifiers which are not allowed to access an instance",
    method: "get",
    name: "ListBlocklistIdentifiers",
    url: "https://api.clerk.com/v1/blocklist_identifiers",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    defs: {},
  },
  {
    description:
      "Create an identifier that is blocked from accessing an instance",
    method: "post",
    name: "CreateBlocklistIdentifier",
    url: "https://api.clerk.com/v1/blocklist_identifiers",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["identifier"],
      type: "object",
      additionalProperties: false,
      properties: {
        identifier: {
          description:
            "The identifier to be added in the block-list.\nThis can be an email address, a phone number or a web3 wallet.",
          type: "string",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Delete an identifier from the instance block-list",
    method: "delete",
    name: "DeleteBlocklistIdentifier",
    url: "https://api.clerk.com/v1/blocklist_identifiers/{identifier_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the identifier to delete from the block-list",
        in: "path",
        name: "identifier_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Updates the settings of an instance",
    method: "patch",
    name: "UpdateInstanceAuthConfig",
    url: "https://api.clerk.com/v1/beta_features/instance_settings",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        restricted_to_allowlist: {
          default: false,
          description:
            "Whether sign up is restricted to email addresses, phone numbers and usernames that are on the allowlist.",
          type: ["boolean", "null"],
        },
        from_email_address: {
          description:
            "The local part of the email address from which authentication-related emails (e.g. OTP code, magic links) will be sent.\nOnly alphanumeric values are allowed.\nNote that this value should contain only the local part of the address (e.g. `foo` for `foo@example.com`).",
          type: ["string", "null"],
        },
        progressive_sign_up: {
          description:
            "Enable the Progressive Sign Up algorithm. Refer to the [docs](https://clerk.com/docs/upgrade-guides/progressive-sign-up) for more info.",
          type: ["boolean", "null"],
        },
        enhanced_email_deliverability: {
          description:
            'The "enhanced_email_deliverability" feature will send emails from "verifications@clerk.dev" instead of your domain.\nThis can be helpful if you do not have a high domain reputation.',
          type: ["boolean", "null"],
        },
        test_mode: {
          description:
            "Toggles test mode for this instance, allowing the use of test email addresses and phone numbers.\nDefaults to true for development instances.",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Change the domain of a production instance.\n\nChanging the domain requires updating the [DNS records](https://clerk.com/docs/deployments/overview#dns-records) accordingly, deploying new [SSL certificates](https://clerk.com/docs/deployments/overview#deploy), updating your Social Connection's redirect URLs and setting the new keys in your code.\n\nWARNING: Changing your domain will invalidate all current user sessions (i.e. users will be logged out). Also, while your application is being deployed, a small downtime is expected to occur.",
    method: "put",
    name: "UpdateProductionInstanceDomain",
    url: "https://api.clerk.com/v1/beta_features/domain",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        home_url: {
          description:
            "The new home URL of the production instance e.g. https://www.example.com",
          type: "string",
        },
        is_secondary: {
          description: "Whether the domain is a secondary app.",
          type: "boolean",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      'Create an actor token that can be used to impersonate the given user.\nThe `actor` parameter needs to include at least a "sub" key whose value is the ID of the actor (impersonating) user.',
    method: "post",
    name: "CreateActorToken",
    url: "https://api.clerk.com/v1/actor_tokens",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["user_id", "actor"],
      type: "object",
      additionalProperties: false,
      properties: {
        user_id: {
          description: "The ID of the user being impersonated.",
          type: "string",
        },
        actor: {
          description:
            "The actor payload. It needs to include a sub property which should contain the ID of the actor.\nThis whole payload will be also included in the JWT session token.",
          required: ["sub"],
          type: "object",
          additionalProperties: true,
          example: {
            sub: "user_2OEpKhcCN1Lat9NQ0G6puh7q5Rb",
          },
          properties: {
            sub: {
              description: "The ID of the actor.",
              type: "string",
            },
          },
        },
        expires_in_seconds: {
          default: 3600,
          description:
            "Optional parameter to specify the life duration of the actor token in seconds.\nBy default, the duration is 1 hour.",
          type: "integer",
        },
        session_max_duration_in_seconds: {
          default: 1800,
          description:
            "The maximum duration that the session which will be created by the generated actor token should last.\nBy default, the duration of a session created via an actor token, lasts 30 minutes.",
          type: "integer",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Revokes a pending actor token.",
    method: "post",
    name: "RevokeActorToken",
    url: "https://api.clerk.com/v1/actor_tokens/{actor_token_id}/revoke",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the actor token to be revoked.",
        in: "path",
        name: "actor_token_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Use this endpoint to get a list of all domains for an instance.\nThe response will contain the primary domain for the instance and any satellite domains. Each domain in the response contains information about the URLs where Clerk operates and the required CNAME targets.",
    method: "get",
    name: "ListDomains",
    url: "https://api.clerk.com/v1/domains",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    defs: {},
  },
  {
    description:
      "Add a new domain for your instance.\nUseful in the case of multi-domain instances, allows adding satellite domains to an instance.\nThe new domain must have a `name`. The domain name can contain the port for development instances, like `localhost:3000`.\nAt the moment, instances can have only one primary domain, so the `is_satellite` parameter must be set to `true`.\nIf you're planning to configure the new satellite domain to run behind a proxy, pass the `proxy_url` parameter accordingly.",
    method: "post",
    name: "AddDomain",
    url: "https://api.clerk.com/v1/domains",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["name", "is_satellite"],
      type: "object",
      properties: {
        name: {
          description:
            "The new domain name. Can contain the port for development instances.",
          type: "string",
        },
        is_satellite: {
          description:
            "Marks the new domain as satellite. Only `true` is accepted at the moment.",
          enum: [true],
          type: "boolean",
        },
        proxy_url: {
          description:
            "The full URL of the proxy which will forward requests to the Clerk Frontend API for this domain. Applicable only to production instances.",
          type: ["string", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Deletes a satellite domain for the instance.\nIt is currently not possible to delete the instance's primary domain.",
    method: "delete",
    name: "DeleteDomain",
    url: "https://api.clerk.com/v1/domains/{domain_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the domain that will be deleted. Must be a satellite domain.",
        in: "path",
        name: "domain_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "The `proxy_url` can be updated only for production instances.\nUpdate one of the instance's domains. Both primary and satellite domains can be updated.\nIf you choose to use Clerk via proxy, use this endpoint to specify the `proxy_url`.\nWhenever you decide you'd rather switch to DNS setup for Clerk, simply set `proxy_url`\nto `null` for the domain. When you update a production instance's primary domain name,\nyou have to make sure that you've completed all the necessary setup steps for DNS and\nemails to work. Expect downtime otherwise. Updating a primary domain's name will also\nupdate the instance's home origin, affecting the default application paths.",
    method: "patch",
    name: "UpdateDomain",
    url: "https://api.clerk.com/v1/domains/{domain_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the domain that will be updated.",
        in: "path",
        name: "domain_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        name: {
          description:
            "The new domain name. For development instances, can contain the port,\ni.e `myhostname:3000`. For production instances, must be a valid FQDN,\ni.e `mysite.com`. Cannot contain protocol scheme.",
          type: ["string", "null"],
        },
        proxy_url: {
          description:
            "The full URL of the proxy that will forward requests to Clerk's Frontend API.\nCan only be updated for production instances.",
          type: ["string", "null"],
        },
        is_secondary: {
          description:
            "Whether this is a domain for a secondary app, meaning that any subdomain provided is significant and\nwill be stored as part of the domain. This is useful for supporting multiple apps (one primary and\nmultiple secondaries) on the same root domain (eTLD+1).",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Fetches the current instance",
    method: "get",
    name: "GetInstance",
    url: "https://api.clerk.com/v1/instance",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    defs: {},
  },
  {
    description: "Updates the settings of an instance",
    method: "patch",
    name: "UpdateInstance",
    url: "https://api.clerk.com/v1/instance",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        test_mode: {
          description:
            "Toggles test mode for this instance, allowing the use of test email addresses and phone numbers.\nDefaults to true for development instances.",
          type: ["boolean", "null"],
        },
        hibp: {
          description:
            "Whether the instance should be using the HIBP service to check passwords for breaches",
          type: ["boolean", "null"],
        },
        enhanced_email_deliverability: {
          description:
            'The "enhanced_email_deliverability" feature will send emails from "verifications@clerk.dev" instead of your domain.\nThis can be helpful if you do not have a high domain reputation.',
          type: ["boolean", "null"],
        },
        support_email: {
          type: ["string", "null"],
        },
        clerk_js_version: {
          type: ["string", "null"],
        },
        development_origin: {
          type: ["string", "null"],
        },
        allowed_origins: {
          description:
            "For browser-like stacks such as browser extensions, Electron, or Capacitor.js the instance allowed origins need to be updated with the request origin value.\nFor Chrome extensions popup, background, or service worker pages the origin is chrome-extension://extension_uiid. For Electron apps the default origin is http://localhost:3000. For Capacitor, the origin is capacitor://localhost.",
          type: "array",
          items: {
            type: "string",
          },
        },
        cookieless_dev: {
          deprecated: true,
          description:
            "Whether the instance should operate in cookieless development mode (i.e. without third-party cookies).\nDeprecated: Please use `url_based_session_syncing` instead.",
          type: ["boolean", "null"],
        },
        url_based_session_syncing: {
          description:
            "Whether the instance should use URL-based session syncing in development mode (i.e. without third-party cookies).",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Updates the restriction settings of an instance",
    method: "patch",
    name: "UpdateInstanceRestrictions",
    url: "https://api.clerk.com/v1/instance/restrictions",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        allowlist: {
          type: ["boolean", "null"],
        },
        blocklist: {
          type: ["boolean", "null"],
        },
        block_email_subaddresses: {
          type: ["boolean", "null"],
        },
        block_disposable_email_domains: {
          type: ["boolean", "null"],
        },
        ignore_dots_for_gmail_addresses: {
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Change the domain of a production instance.\n\nChanging the domain requires updating the [DNS records](https://clerk.com/docs/deployments/overview#dns-records) accordingly, deploying new [SSL certificates](https://clerk.com/docs/deployments/overview#deploy), updating your Social Connection's redirect URLs and setting the new keys in your code.\n\nWARNING: Changing your domain will invalidate all current user sessions (i.e. users will be logged out). Also, while your application is being deployed, a small downtime is expected to occur.",
    method: "post",
    name: "ChangeProductionInstanceDomain",
    url: "https://api.clerk.com/v1/instance/change_domain",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        home_url: {
          description:
            "The new home URL of the production instance e.g. https://www.example.com",
          type: "string",
        },
        is_secondary: {
          description:
            "Whether this is a domain for a secondary app, meaning that any subdomain provided is significant and\nwill be stored as part of the domain. This is useful for supporting multiple apps (one primary and\nmultiple secondaries) on the same root domain (eTLD+1).",
          type: "boolean",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Updates the organization settings of the instance",
    method: "patch",
    name: "UpdateInstanceOrganizationSettings",
    url: "https://api.clerk.com/v1/instance/organization_settings",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        enabled: {
          type: ["boolean", "null"],
        },
        max_allowed_memberships: {
          type: ["integer", "null"],
        },
        admin_delete_enabled: {
          type: ["boolean", "null"],
        },
        domains_enabled: {
          type: ["boolean", "null"],
        },
        domains_enrollment_modes: {
          description:
            "Specify which enrollment modes to enable for your Organization Domains.\nSupported modes are 'automatic_invitation' & 'automatic_suggestion'.",
          type: "array",
          items: {
            type: "string",
          },
        },
        creator_role_id: {
          description:
            "Specify what the default organization role is for an organization creator.",
          type: ["string", "null"],
        },
        domains_default_role_id: {
          description:
            "Specify what the default organization role is for the organization domains.",
          type: ["string", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Create a Svix app and associate it with the current instance",
    method: "post",
    name: "CreateSvixApp",
    url: "https://api.clerk.com/v1/webhooks/svix",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    defs: {},
  },
  {
    description:
      "Delete a Svix app and disassociate it from the current instance",
    method: "delete",
    name: "DeleteSvixApp",
    url: "https://api.clerk.com/v1/webhooks/svix",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    defs: {},
  },
  {
    description:
      "Generate a new url for accessing the Svix's management dashboard for that particular instance",
    method: "post",
    name: "GenerateSvixAuthURL",
    url: "https://api.clerk.com/v1/webhooks/svix_url",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    defs: {},
  },
  {
    description: "List all templates",
    method: "get",
    name: "ListJWTTemplates",
    url: "https://api.clerk.com/v1/jwt_templates",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Whether to paginate the results.\nIf true, the results will be paginated.\nIf false, the results will not be paginated.",
        in: "query",
        name: "paginated",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description: "Create a new JWT template",
    method: "post",
    name: "CreateJWTTemplate",
    url: "https://api.clerk.com/v1/jwt_templates",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["name", "claims"],
      type: "object",
      properties: {
        name: {
          description: "JWT template name",
          type: "string",
        },
        claims: {
          description: "JWT template claims in JSON format",
          type: "object",
        },
        lifetime: {
          description: "JWT token lifetime",
          maximum: 315360000,
          minimum: 30,
          type: ["number", "null"],
        },
        allowed_clock_skew: {
          description: "JWT token allowed clock skew",
          maximum: 300,
          minimum: 0,
          type: ["number", "null"],
        },
        custom_signing_key: {
          description:
            "Whether a custom signing key/algorithm is also provided for this template",
          type: "boolean",
        },
        signing_algorithm: {
          description:
            "The custom signing algorithm to use when minting JWTs. Required if `custom_signing_key` is `true`.",
          type: ["string", "null"],
        },
        signing_key: {
          description:
            "The custom signing private key to use when minting JWTs. Required if `custom_signing_key` is `true`.",
          type: ["string", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Retrieve the details of a given JWT template",
    method: "get",
    name: "GetJWTTemplate",
    url: "https://api.clerk.com/v1/jwt_templates/{template_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "JWT Template ID",
        in: "path",
        name: "template_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Delete a Template",
    method: "delete",
    name: "DeleteJWTTemplate",
    url: "https://api.clerk.com/v1/jwt_templates/{template_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "JWT Template ID",
        in: "path",
        name: "template_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Updates an existing JWT template",
    method: "patch",
    name: "UpdateJWTTemplate",
    url: "https://api.clerk.com/v1/jwt_templates/{template_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the JWT template to update",
        in: "path",
        name: "template_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      required: ["name", "claims"],
      type: "object",
      properties: {
        name: {
          description: "JWT template name",
          type: "string",
        },
        claims: {
          description: "JWT template claims in JSON format",
          type: "object",
        },
        lifetime: {
          description: "JWT token lifetime",
          maximum: 315360000,
          minimum: 30,
          type: ["number", "null"],
        },
        allowed_clock_skew: {
          description: "JWT token allowed clock skew",
          maximum: 300,
          minimum: 0,
          type: ["number", "null"],
        },
        custom_signing_key: {
          description:
            "Whether a custom signing key/algorithm is also provided for this template",
          type: "boolean",
        },
        signing_algorithm: {
          description:
            "The custom signing algorithm to use when minting JWTs. Required if `custom_signing_key` is `true`.",
          type: ["string", "null"],
        },
        signing_key: {
          description:
            "The custom signing private key to use when minting JWTs. Required if `custom_signing_key` is `true`.",
          type: ["string", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "This request returns the list of organizations for an instance.\nResults can be paginated using the optional `limit` and `offset` query parameters.\nThe organizations are ordered by descending creation date.\nMost recent organizations will be returned first.",
    method: "get",
    name: "ListOrganizations",
    url: "https://api.clerk.com/v1/organizations",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Flag to denote whether the member counts of each organization should be included in the response or not.",
        in: "query",
        name: "include_members_count",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Flag to denote whether or not to include a member with elevated permissions who is not currently a member of the organization.",
        in: "query",
        name: "include_missing_member_with_elevated_permissions",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Returns organizations with ID, name, or slug that match the given query.\nUses exact match for organization ID and partial match for name and slug.",
        in: "query",
        name: "query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns organizations with the user ids specified. Any user ids not found are ignored.\nFor each user id, the `+` and `-` can be prepended to the id, which denote whether the\nrespective organization should be included or excluded from the result set.",
        in: "query",
        name: "user_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns organizations with the organization ids specified. Any organization ids not found are ignored.\nFor each organization id, the `+` and `-` can be prepended to the id, which denote whether the\nrespective organization should be included or excluded from the result set. Accepts up to 100 organization ids.\nExample: ?organization_id=+org_1&organization_id=-org_2",
        in: "query",
        name: "organization_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Allows to return organizations in a particular order.\nAt the moment, you can order the returned organizations either by their `name`, `created_at` or `members_count`.\nIn order to specify the direction, you can use the `+/-` symbols prepended in the property to order by.\nFor example, if you want organizations to be returned in descending order according to their `created_at` property, you can use `-created_at`.\nIf you don't use `+` or `-`, then `+` is implied.\nDefaults to `-created_at`.",
        in: "query",
        name: "order_by",
        required: false,
        explode: true,
        schema: {
          default: "-created_at",
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      'Creates a new organization with the given name for an instance.\nYou can specify an optional slug for the new organization.\nIf provided, the organization slug can contain only lowercase alphanumeric characters (letters and digits) and the dash "-".\nOrganization slugs must be unique for the instance.\nYou can provide additional metadata for the organization and set any custom attribute you want.\nOrganizations support private and public metadata.\nPrivate metadata can only be accessed from the Backend API.\nPublic metadata can be accessed from the Backend API, and are read-only from the Frontend API.\nThe `created_by` user will see this as their [active organization] (https://clerk.com/docs/organizations/overview#active-organization)\nthe next time they create a session, presuming they don\'t explicitly set a different organization as active before then.',
    method: "post",
    name: "CreateOrganization",
    url: "https://api.clerk.com/v1/organizations",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["name"],
      type: "object",
      properties: {
        name: {
          description:
            "The name of the new organization.\nMay not contain URLs or HTML.\nMax length: 256",
          type: "string",
        },
        created_by: {
          description:
            "The ID of the User who will become the administrator for the new organization",
          type: ["string", "null"],
        },
        private_metadata: {
          description:
            "Metadata saved on the organization, accessible only from the Backend API",
          type: ["object", "null"],
          additionalProperties: true,
        },
        public_metadata: {
          description:
            "Metadata saved on the organization, read-only from the Frontend API and fully accessible (read/write) from the Backend API",
          type: ["object", "null"],
          additionalProperties: true,
        },
        slug: {
          description:
            'A slug for the new organization.\nCan contain only lowercase alphanumeric characters and the dash "-".\nMust be unique for the instance.',
          type: ["string", "null"],
        },
        max_allowed_memberships: {
          description:
            "The maximum number of memberships allowed for this organization",
          minimum: 0,
          type: ["integer", "null"],
        },
        created_at: {
          description:
            "A custom date/time denoting _when_ the organization was created, specified in RFC3339 format (e.g. `2012-10-20T07:15:20.902Z`).",
          type: ["string", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Fetches the organization whose ID or slug matches the provided `id_or_slug` URL query parameter.",
    method: "get",
    name: "GetOrganization",
    url: "https://api.clerk.com/v1/organizations/{organization_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID or slug of the organization",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          "Flag to denote whether or not the organization's members count should be included in the response.",
        in: "query",
        name: "include_members_count",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Flag to denote whether or not to include a member with elevated permissions who is not currently a member of the organization.",
        in: "query",
        name: "include_missing_member_with_elevated_permissions",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Deletes the given organization.\nPlease note that deleting an organization will also delete all memberships and invitations.\nThis is not reversible.",
    method: "delete",
    name: "DeleteOrganization",
    url: "https://api.clerk.com/v1/organizations/{organization_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the organization to delete",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Updates an existing organization",
    method: "patch",
    name: "UpdateOrganization",
    url: "https://api.clerk.com/v1/organizations/{organization_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the organization to update",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        public_metadata: {
          description:
            "Metadata saved on the organization, that is visible to both your frontend and backend.",
          type: ["object", "null"],
          additionalProperties: true,
        },
        private_metadata: {
          description:
            "Metadata saved on the organization that is only visible to your backend.",
          type: ["object", "null"],
          additionalProperties: true,
        },
        name: {
          description:
            "The new name of the organization.\nMay not contain URLs or HTML.\nMax length: 256",
          type: ["string", "null"],
        },
        slug: {
          description:
            "The new slug of the organization, which needs to be unique in the instance",
          type: ["string", "null"],
        },
        max_allowed_memberships: {
          description:
            "The maximum number of memberships allowed for this organization",
          minimum: 0,
          type: ["integer", "null"],
        },
        admin_delete_enabled: {
          description:
            "If true, an admin can delete this organization with the Frontend API.",
          type: ["boolean", "null"],
        },
        created_at: {
          description:
            "A custom date/time denoting _when_ the organization was created, specified in RFC3339 format (e.g. `2012-10-20T07:15:20.902Z`).",
          type: ["string", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Update organization metadata attributes by merging existing values with the provided parameters.\nMetadata values will be updated via a deep merge.\nDeep meaning that any nested JSON objects will be merged as well.\nYou can remove metadata keys at any level by setting their value to `null`.",
    method: "patch",
    name: "MergeOrganizationMetadata",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/metadata",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the organization for which metadata will be merged or updated",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        public_metadata: {
          description:
            "Metadata saved on the organization, that is visible to both your frontend and backend.\nThe new object will be merged with the existing value.",
          type: "object",
          additionalProperties: true,
        },
        private_metadata: {
          description:
            "Metadata saved on the organization that is only visible to your backend.\nThe new object will be merged with the existing value.",
          type: "object",
          additionalProperties: true,
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Set or replace an organization's logo, by uploading an image file.\nThis endpoint uses the `multipart/form-data` request content type and accepts a file of image type.\nThe file size cannot exceed 10MB.\nOnly the following file content types are supported: `image/jpeg`, `image/png`, `image/gif`, `image/webp`, `image/x-icon`, `image/vnd.microsoft.icon`.",
    method: "put",
    name: "UploadOrganizationLogo",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/logo",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the organization for which to upload a logo",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Delete the organization's logo.",
    method: "delete",
    name: "DeleteOrganizationLogo",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/logo",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the organization for which the logo will be deleted.",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "This request returns the list of organization invitations.\nResults can be paginated using the optional `limit` and `offset` query parameters.\nYou can filter them by providing the 'status' query parameter, that accepts multiple values.\nThe organization invitations are ordered by descending creation date.\nMost recent invitations will be returned first.\nAny invitations created as a result of an Organization Domain are not included in the results.",
    method: "get",
    name: "ListOrganizationInvitations",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/invitations",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The organization ID.",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "Filter organization invitations based on their status",
        in: "query",
        name: "status",
        required: false,
        explode: true,
        schema: {
          enum: ["pending", "accepted", "revoked"],
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      'Creates a new organization invitation and sends an email to the provided `email_address` with a link to accept the invitation and join the organization.\nYou can specify the `role` for the invited organization member.\n\nNew organization invitations get a "pending" status until they are revoked by an organization administrator or accepted by the invitee.\n\nThe request body supports passing an optional `redirect_url` parameter.\nWhen the invited user clicks the link to accept the invitation, they will be redirected to the URL provided.\nUse this parameter to implement a custom invitation acceptance flow.\n\nYou can specify the ID of the user that will send the invitation with the `inviter_user_id` parameter.\nThat user must be a member with administrator privileges in the organization.\nOnly "admin" members can create organization invitations.\n\nYou can optionally provide public and private metadata for the organization invitation.\nThe public metadata are visible by both the Frontend and the Backend whereas the private ones only by the Backend.\nWhen the organization invitation is accepted, the metadata will be transferred to the newly created organization membership.',
    method: "post",
    name: "CreateOrganizationInvitation",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/invitations",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the organization for which to send the invitation",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      required: ["email_address", "role"],
      type: "object",
      properties: {
        email_address: {
          description:
            "The email address of the new member that is going to be invited to the organization",
          type: "string",
        },
        inviter_user_id: {
          description:
            "The ID of the user that invites the new member to the organization.\nMust be an administrator in the organization.",
          type: ["string", "null"],
        },
        role: {
          description: "The role of the new member in the organization",
          type: "string",
        },
        public_metadata: {
          description:
            "Metadata saved on the organization invitation, read-only from the Frontend API and fully accessible (read/write) from the Backend API.\nWhen the organization invitation is accepted, the metadata will be transferred to the newly created organization membership.",
          type: ["object", "null"],
          additionalProperties: true,
        },
        private_metadata: {
          description:
            "Metadata saved on the organization invitation, fully accessible (read/write) from the Backend API but not visible from the Frontend API.\nWhen the organization invitation is accepted, the metadata will be transferred to the newly created organization membership.",
          type: ["object", "null"],
          additionalProperties: true,
        },
        redirect_url: {
          description:
            "Optional URL that the invitee will be redirected to once they accept the invitation by clicking the join link in the invitation email.",
          type: ["string", "null"],
        },
        expires_in_days: {
          description:
            "The number of days the invitation will be valid for. By default, the invitation has a 30 days expire.",
          maximum: 365,
          minimum: 1,
          type: ["integer", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      'Creates new organization invitations in bulk and sends out emails to the provided email addresses with a link to accept the invitation and join the organization.\nYou can specify a different `role` for each invited organization member.\nNew organization invitations get a "pending" status until they are revoked by an organization administrator or accepted by the invitee.\nThe request body supports passing an optional `redirect_url` parameter for each invitation.\nWhen the invited user clicks the link to accept the invitation, they will be redirected to the provided URL.\nUse this parameter to implement a custom invitation acceptance flow.\nYou can specify the ID of the user that will send the invitation with the `inviter_user_id` parameter. Each invitation\ncan have a different inviter user.\nInviter users must be members with administrator privileges in the organization.\nOnly "admin" members can create organization invitations.\nYou can optionally provide public and private metadata for each organization invitation. The public metadata are visible\nby both the Frontend and the Backend, whereas the private metadata are only visible by the Backend.\nWhen the organization invitation is accepted, the metadata will be transferred to the newly created organization membership.',
    method: "post",
    name: "CreateOrganizationInvitationBulk",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/invitations/bulk",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The organization ID.",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "array",
      items: {
        required: ["email_address", "role"],
        type: "object",
        properties: {
          email_address: {
            description:
              "The email address of the new member that is going to be invited to the organization",
            type: "string",
          },
          inviter_user_id: {
            description:
              "The ID of the user that invites the new member to the organization.\nMust be an administrator in the organization.",
            type: ["string", "null"],
          },
          role: {
            description: "The role of the new member in the organization",
            type: "string",
          },
          public_metadata: {
            description:
              "Metadata saved on the organization invitation, read-only from the Frontend API and fully accessible (read/write) from the Backend API.\nWhen the organization invitation is accepted, the metadata will be transferred to the newly created organization membership.",
            type: ["object", "null"],
            additionalProperties: true,
          },
          private_metadata: {
            description:
              "Metadata saved on the organization invitation, fully accessible (read/write) from the Backend API but not visible from the Frontend API.\nWhen the organization invitation is accepted, the metadata will be transferred to the newly created organization membership.",
            type: ["object", "null"],
            additionalProperties: true,
          },
          redirect_url: {
            description:
              "Optional URL that the invitee will be redirected to once they accept the invitation by clicking the join link in the invitation email.",
            type: ["string", "null"],
          },
          expires_in_days: {
            description:
              "The number of days the invitation will be valid for. By default, the invitation has a 30 days expire.",
            maximum: 365,
            minimum: 1,
            type: ["integer", "null"],
          },
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      'This request returns the list of organization invitations with "pending" status.\nThese are the organization invitations that can still be used to join the organization, but have not been accepted by the invited user yet.\nResults can be paginated using the optional `limit` and `offset` query parameters.\nThe organization invitations are ordered by descending creation date.\nMost recent invitations will be returned first.\nAny invitations created as a result of an Organization Domain are not included in the results.',
    method: "get",
    name: "ListPendingOrganizationInvitations",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/invitations/pending",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The organization ID.",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Use this request to get an existing organization invitation by ID.",
    method: "get",
    name: "GetOrganizationInvitation",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/invitations/{invitation_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The organization ID.",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The organization invitation ID.",
        in: "path",
        name: "invitation_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      'Use this request to revoke a previously issued organization invitation.\nRevoking an organization invitation makes it invalid; the invited user will no longer be able to join the organization with the revoked invitation.\nOnly organization invitations with "pending" status can be revoked.\nThe request accepts the `requesting_user_id` parameter to specify the user which revokes the invitation.\nOnly users with "admin" role can revoke invitations.',
    method: "post",
    name: "RevokeOrganizationInvitation",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/invitations/{invitation_id}/revoke",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The organization ID.",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The organization invitation ID.",
        in: "path",
        name: "invitation_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      properties: {
        requesting_user_id: {
          description:
            "The ID of the user that revokes the invitation.\nMust be an administrator in the organization.",
          type: ["string", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Retrieves all user memberships for the given organization",
    method: "get",
    name: "ListOrganizationMemberships",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/memberships",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The organization ID.",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          'Sorts organizations memberships by phone_number, email_address, created_at, first_name, last_name or username.\nBy prepending one of those values with + or -, we can choose to sort in ascending (ASC) or descending (DESC) order."',
        in: "query",
        name: "order_by",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with the user ids specified. For each user id, the `+` and `-` can be\nprepended to the id, which denote whether the respective user id should be included or\nexcluded from the result set. Accepts up to 100 user ids. Any user ids not found are ignored.",
        in: "query",
        name: "user_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the specified email addresses. Accepts up to 100 email addresses. Any email addresses not found are ignored.",
        in: "query",
        name: "email_address",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the specified phone numbers. Accepts up to 100 phone numbers. Any phone numbers not found are ignored.",
        in: "query",
        name: "phone_number",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the specified usernames.\nAccepts up to 100 usernames.\nAny usernames not found are ignored.",
        in: "query",
        name: "username",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the specified web3 wallet addresses.\nAccepts up to 100 web3 wallet addresses.\nAny web3 wallet addressed not found are ignored.",
        in: "query",
        name: "web3_wallet",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users with the specified roles. Accepts up to 100 roles. Any roles not found are ignored.",
        in: "query",
        name: "role",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
      {
        description:
          "Returns users that match the given query.\nFor possible matches, we check the email addresses, phone numbers, usernames, web3 wallets, user ids, first and last names.\nThe query value doesn't need to match the exact value you are looking for, it is capable of partial matches as well.",
        in: "query",
        name: "query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with emails that match the given query, via case-insensitive partial match.\nFor example, `email_address_query=ello` will match a user with the email `HELLO@example.com`.",
        in: "query",
        name: "email_address_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with phone numbers that match the given query, via case-insensitive partial match.\nFor example, `phone_number_query=555` will match a user with the phone number `+1555xxxxxxx`.",
        in: "query",
        name: "phone_number_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with usernames that match the given query, via case-insensitive partial match.\nFor example, `username_query=CoolUser` will match a user with the username `SomeCoolUser`.",
        in: "query",
        name: "username_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users with names that match the given query, via case-insensitive partial match.",
        in: "query",
        name: "name_query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns users whose last session activity was before the given date (with millisecond precision).\nExample: use 1700690400000 to retrieve users whose last session activity was before 2023-11-23.",
        in: "query",
        name: "last_active_at_before",
        required: false,
        example: 1700690400000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns users whose last session activity was after the given date (with millisecond precision).\nExample: use 1700690400000 to retrieve users whose last session activity was after 2023-11-23.",
        in: "query",
        name: "last_active_at_after",
        required: false,
        example: 1700690400000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns users who have been created before the given date (with millisecond precision).\nExample: use 1730160000000 to retrieve users who have been created before 2024-10-29.",
        in: "query",
        name: "created_at_before",
        required: false,
        example: 1730160000000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns users who have been created after the given date (with millisecond precision).\nExample: use 1730160000000 to retrieve users who have been created after 2024-10-29.",
        in: "query",
        name: "created_at_after",
        required: false,
        example: 1730160000000,
        explode: true,
        schema: {
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Adds a user as a member to the given organization.\nOnly users in the same instance as the organization can be added as members.\n\nThis organization will be the user's [active organization] (https://clerk.com/docs/organizations/overview#active-organization)\nthe next time they create a session, presuming they don't explicitly set a\ndifferent organization as active before then.",
    method: "post",
    name: "CreateOrganizationMembership",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/memberships",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the organization where the new membership will be created",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      required: ["user_id", "role"],
      type: "object",
      properties: {
        user_id: {
          description:
            "The ID of the user that will be added as a member in the organization.\nThe user needs to exist in the same instance as the organization and must not be a member of the given organization already.",
          type: "string",
        },
        role: {
          description:
            "The role that the new member will have in the organization.",
          type: "string",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Removes the given membership from the organization",
    method: "delete",
    name: "DeleteOrganizationMembership",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/memberships/{user_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the organization the membership belongs to",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The ID of the user that this membership belongs to",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Updates the properties of an existing organization membership",
    method: "patch",
    name: "UpdateOrganizationMembership",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/memberships/{user_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the organization the membership belongs to",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The ID of the user that this membership belongs to",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      required: ["role"],
      type: "object",
      properties: {
        role: {
          description: "The new role of the given membership.",
          type: "string",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Update an organization membership's metadata attributes by merging existing values with the provided parameters.\nMetadata values will be updated via a deep merge. Deep means that any nested JSON objects will be merged as well.\nYou can remove metadata keys at any level by setting their value to `null`.",
    method: "patch",
    name: "UpdateOrganizationMembershipMetadata",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/memberships/{user_id}/metadata",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the organization the membership belongs to",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The ID of the user that this membership belongs to",
        in: "path",
        name: "user_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        public_metadata: {
          description:
            "Metadata saved on the organization membership, that is visible to both your frontend and backend.\nThe new object will be merged with the existing value.",
          type: "object",
          additionalProperties: true,
        },
        private_metadata: {
          description:
            "Metadata saved on the organization membership that is only visible to your backend.\nThe new object will be merged with the existing value.",
          type: "object",
          additionalProperties: true,
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Get a list of all domains of an organization.",
    method: "get",
    name: "ListOrganizationDomains",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/domains",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The organization ID.",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description:
          "Filter domains by their verification status. `true` or `false`",
        in: "query",
        name: "verified",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "Filter domains by their enrollment mode",
        in: "query",
        name: "enrollment_mode",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Creates a new organization domain. By default the domain is verified, but can be optionally set to unverified.",
    method: "post",
    name: "CreateOrganizationDomain",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/domains",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the organization where the new domain will be created.",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        name: {
          description: "The name of the new domain",
          type: "string",
        },
        enrollment_mode: {
          description:
            "The enrollment_mode for the new domain. This can be `automatic_invitation`, `automatic_suggestion` or `manual_invitation`",
          type: "string",
        },
        verified: {
          description: "The status of domain's verification. Defaults to true",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Removes the given domain from the organization.",
    method: "delete",
    name: "DeleteOrganizationDomain",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/domains/{domain_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the organization the domain belongs to",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The ID of the domain",
        in: "path",
        name: "domain_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Updates the properties of an existing organization domain.",
    method: "patch",
    name: "UpdateOrganizationDomain",
    url: "https://api.clerk.com/v1/organizations/{organization_id}/domains/{domain_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the organization the domain belongs to",
        in: "path",
        name: "organization_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
      {
        description: "The ID of the domain",
        in: "path",
        name: "domain_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      properties: {
        enrollment_mode: {
          description:
            "The enrollment_mode for the new domain. This can be `automatic_invitation`, `automatic_suggestion` or `manual_invitation`",
          type: ["string", "null"],
        },
        verified: {
          description: "The status of the domain's verification",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "This endpoint can be used to validate that a proxy-enabled domain is operational.\nIt tries to verify that the proxy URL provided in the parameters maps to a functional proxy that can reach the Clerk Frontend API.\n\nYou can use this endpoint before you set a proxy URL for a domain. This way you can ensure that switching to proxy-based\nconfiguration will not lead to downtime for your instance.\n\nThe `proxy_url` parameter allows for testing proxy configurations for domains that don't have a proxy URL yet, or operate on\na different proxy URL than the one provided. It can also be used to re-validate a domain that is already configured to work with a proxy.",
    method: "post",
    name: "VerifyDomainProxy",
    url: "https://api.clerk.com/v1/proxy_checks",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      type: "object",
      properties: {
        domain_id: {
          description: "The ID of the domain that will be updated.",
          type: "string",
        },
        proxy_url: {
          description:
            "The full URL of the proxy which will forward requests to the Clerk Frontend API for this domain. e.g. https://example.com/__clerk",
          type: "string",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Lists all whitelisted redirect_urls for the instance",
    method: "get",
    name: "ListRedirectURLs",
    url: "https://api.clerk.com/v1/redirect_urls",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Whether to paginate the results.\nIf true, the results will be paginated.\nIf false, the results will not be paginated.",
        in: "query",
        name: "paginated",
        required: false,
        explode: true,
        schema: {
          type: "boolean",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description: "Create a redirect URL",
    method: "post",
    name: "CreateRedirectURL",
    url: "https://api.clerk.com/v1/redirect_urls",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["url"],
      type: "object",
      properties: {
        url: {
          description:
            'The full url value prefixed with `https://` or a custom scheme e.g. `"https://my-app.com/oauth-callback"` or `"my-app://oauth-callback"`',
          type: "string",
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Retrieve the details of the redirect URL with the given ID",
    method: "get",
    name: "GetRedirectURL",
    url: "https://api.clerk.com/v1/redirect_urls/{id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the redirect URL",
        in: "path",
        name: "id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Remove the selected redirect URL from the whitelist of the instance",
    method: "delete",
    name: "DeleteRedirectURL",
    url: "https://api.clerk.com/v1/redirect_urls/{id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the redirect URL",
        in: "path",
        name: "id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Creates a new sign-in token and associates it with the given user.\nBy default, sign-in tokens expire in 30 days.\nYou can optionally supply a different duration in seconds using the `expires_in_seconds` property.",
    method: "post",
    name: "CreateSignInToken",
    url: "https://api.clerk.com/v1/sign_in_tokens",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["user_id"],
      type: "object",
      properties: {
        user_id: {
          description:
            "The ID of the user that can use the newly created sign in token",
          type: "string",
        },
        expires_in_seconds: {
          default: 2592000,
          description:
            "Optional parameter to specify the life duration of the sign in token in seconds.\nBy default, the duration is 30 days.",
          minimum: 1,
          type: ["integer", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Revokes a pending sign-in token",
    method: "post",
    name: "RevokeSignInToken",
    url: "https://api.clerk.com/v1/sign_in_tokens/{sign_in_token_id}/revoke",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the sign-in token to be revoked",
        in: "path",
        name: "sign_in_token_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Retrieve the details of the sign-up with the given ID",
    method: "get",
    name: "GetSignUp",
    url: "https://api.clerk.com/v1/sign_ups/{id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the sign-up to retrieve",
        in: "path",
        name: "id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Update the sign-up with the given ID",
    method: "patch",
    name: "UpdateSignUp",
    url: "https://api.clerk.com/v1/sign_ups/{id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the sign-up to update",
        in: "path",
        name: "id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      properties: {
        external_id: {
          description:
            "The ID of the guest attempting to sign up as used in your external systems or your previous authentication solution.\nThis will be copied to the resulting user when the sign-up is completed.",
          type: ["string", "null"],
        },
        custom_action: {
          description:
            "If true, the sign-up will be marked as a custom action.",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "This request returns the list of OAuth applications for an instance.\nResults can be paginated using the optional `limit` and `offset` query parameters.\nThe OAuth applications are ordered by descending creation date.\nMost recent OAuth applications will be returned first.",
    method: "get",
    name: "ListOAuthApplications",
    url: "https://api.clerk.com/v1/oauth_applications",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Creates a new OAuth application with the given name and callback URL for an instance.\nThe callback URL must be a valid url.\nAll URL schemes are allowed such as `http://`, `https://`, `myapp://`, etc...",
    method: "post",
    name: "CreateOAuthApplication",
    url: "https://api.clerk.com/v1/oauth_applications",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["name"],
      type: "object",
      properties: {
        name: {
          description:
            "The name of the new OAuth application.\nMax length: 256",
          type: "string",
        },
        redirect_uris: {
          description: "An array of redirect URIs of the new OAuth application",
          type: ["array", "null"],
          items: {
            type: "string",
          },
        },
        callback_url: {
          deprecated: true,
          description: "The callback URL of the new OAuth application",
          maxLength: 1024,
          type: ["string", "null"],
        },
        scopes: {
          default: "profile email",
          description:
            "Define the allowed scopes for the new OAuth applications that dictate the user payload of the OAuth user info endpoint. Available scopes are `profile`, `email`, `public_metadata`, `private_metadata`. Provide the requested scopes as a string, separated by spaces.",
          maxLength: 1024,
          type: ["string", "null"],
          example: "profile email public_metadata",
        },
        public: {
          description:
            "If true, this client is public and you can use the Proof Key of Code Exchange (PKCE) flow.",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Fetches the OAuth application whose ID matches the provided `id` in the path.",
    method: "get",
    name: "GetOAuthApplication",
    url: "https://api.clerk.com/v1/oauth_applications/{oauth_application_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the OAuth application",
        in: "path",
        name: "oauth_application_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Deletes the given OAuth application.\nThis is not reversible.",
    method: "delete",
    name: "DeleteOAuthApplication",
    url: "https://api.clerk.com/v1/oauth_applications/{oauth_application_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the OAuth application to delete",
        in: "path",
        name: "oauth_application_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description: "Updates an existing OAuth application",
    method: "patch",
    name: "UpdateOAuthApplication",
    url: "https://api.clerk.com/v1/oauth_applications/{oauth_application_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the OAuth application to update",
        in: "path",
        name: "oauth_application_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        name: {
          description:
            "The new name of the OAuth application.\nMax length: 256",
          type: ["string", "null"],
        },
        redirect_uris: {
          description: "An array of redirect URIs of the new OAuth application",
          type: ["array", "null"],
          items: {
            type: "string",
          },
        },
        callback_url: {
          deprecated: true,
          description: "The new callback URL of the OAuth application",
          maxLength: 1024,
          type: ["string", "null"],
        },
        scopes: {
          default: "profile email",
          description:
            "Define the allowed scopes for the new OAuth applications that dictate the user payload of the OAuth user info endpoint. Available scopes are `profile`, `email`, `public_metadata`, `private_metadata`. Provide the requested scopes as a string, separated by spaces.",
          maxLength: 1024,
          type: ["string", "null"],
          example: "profile email public_metadata private_metadata",
        },
        public: {
          description:
            "If true, this client is public and you can use the Proof Key of Code Exchange (PKCE) flow.",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Rotates the OAuth application's client secret.\nWhen the client secret is rotated, make sure to update it in authorized OAuth clients.",
    method: "post",
    name: "RotateOAuthApplicationSecret",
    url: "https://api.clerk.com/v1/oauth_applications/{oauth_application_id}/rotate_secret",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "The ID of the OAuth application for which to rotate the client secret",
        in: "path",
        name: "oauth_application_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Returns the list of SAML Connections for an instance.\nResults can be paginated using the optional `limit` and `offset` query parameters.\nThe SAML Connections are ordered by descending creation date and the most recent will be returned first.",
    method: "get",
    name: "ListSAMLConnections",
    url: "https://api.clerk.com/v1/saml_connections",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Returns SAML connections that have a name that matches the given query, via case-insensitive partial match.",
        in: "query",
        name: "query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Sorts organizations memberships by phone_number, email_address, created_at, first_name, last_name or username.\nBy prepending one of those values with + or -,\nwe can choose to sort in ascending (ASC) or descending (DESC) order.",
        in: "query",
        name: "order_by",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Returns SAML connections that have an associated organization ID to the\ngiven organizations.\nFor each organization id, the `+` and `-` can be\nprepended to the id, which denote whether the\nrespective organization should be included or\nexcluded from the result set.\nAccepts up to 100 organization ids.",
        in: "query",
        name: "organization_id",
        required: false,
        explode: true,
        schema: {
          type: "array",
          items: {
            type: "string",
          },
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description: "Create a new SAML Connection.",
    method: "post",
    name: "CreateSAMLConnection",
    url: "https://api.clerk.com/v1/saml_connections",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["name", "domain", "provider"],
      type: "object",
      additionalProperties: false,
      properties: {
        name: {
          description: "The name to use as a label for this SAML Connection",
          type: "string",
        },
        domain: {
          description:
            "The domain of your organization. Sign in flows using an email with this domain, will use this SAML Connection.",
          type: "string",
        },
        provider: {
          description: "The IdP provider of the connection.",
          enum: ["saml_custom", "saml_okta", "saml_google", "saml_microsoft"],
          type: "string",
        },
        idp_entity_id: {
          description: "The Entity ID as provided by the IdP",
          type: ["string", "null"],
        },
        idp_sso_url: {
          description: "The Single-Sign On URL as provided by the IdP",
          type: ["string", "null"],
        },
        idp_certificate: {
          description: "The X.509 certificate as provided by the IdP",
          type: ["string", "null"],
        },
        idp_metadata_url: {
          description:
            "The URL which serves the IdP metadata. If present, it takes priority over the corresponding individual properties",
          type: ["string", "null"],
        },
        idp_metadata: {
          description:
            "The XML content of the IdP metadata file. If present, it takes priority over the corresponding individual properties",
          type: ["string", "null"],
        },
        organization_id: {
          description:
            "The ID of the organization to which users of this SAML Connection will be added",
          type: ["string", "null"],
        },
        attribute_mapping: {
          description:
            "Define the attribute name mapping between Identity Provider and Clerk's user properties",
          type: ["object", "null"],
          additionalProperties: false,
          properties: {
            user_id: {
              type: "string",
            },
            email_address: {
              type: "string",
            },
            first_name: {
              type: "string",
            },
            last_name: {
              type: "string",
            },
          },
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description:
      "Fetches the SAML Connection whose ID matches the provided `saml_connection_id` in the path.",
    method: "get",
    name: "GetSAMLConnection",
    url: "https://api.clerk.com/v1/saml_connections/{saml_connection_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the SAML Connection",
        in: "path",
        name: "saml_connection_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Deletes the SAML Connection whose ID matches the provided `id` in the path.",
    method: "delete",
    name: "DeleteSAMLConnection",
    url: "https://api.clerk.com/v1/saml_connections/{saml_connection_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the SAML Connection to delete",
        in: "path",
        name: "saml_connection_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    defs: {},
  },
  {
    description:
      "Updates the SAML Connection whose ID matches the provided `id` in the path.",
    method: "patch",
    name: "UpdateSAMLConnection",
    url: "https://api.clerk.com/v1/saml_connections/{saml_connection_id}",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description: "The ID of the SAML Connection to update",
        in: "path",
        name: "saml_connection_id",
        required: true,
        explode: false,
        schema: {
          type: "string",
        },
        style: "simple",
      },
    ],
    body: {
      type: "object",
      additionalProperties: false,
      properties: {
        name: {
          description: "The name of the new SAML Connection",
          type: ["string", "null"],
        },
        domain: {
          description: "The domain to use for the new SAML Connection",
          type: ["string", "null"],
        },
        idp_entity_id: {
          description: "The entity id as provided by the IdP",
          type: ["string", "null"],
        },
        idp_sso_url: {
          description: "The SSO url as provided by the IdP",
          type: ["string", "null"],
        },
        idp_certificate: {
          description: "The x509 certificated as provided by the IdP",
          type: ["string", "null"],
        },
        idp_metadata_url: {
          description:
            "The URL which serves the IdP metadata. If present, it takes priority over the corresponding individual properties and replaces them",
          type: ["string", "null"],
        },
        idp_metadata: {
          description:
            "The XML content of the IdP metadata file. If present, it takes priority over the corresponding individual properties",
          type: ["string", "null"],
        },
        organization_id: {
          description:
            "The ID of the organization to which users of this SAML Connection will be added",
          type: ["string", "null"],
        },
        attribute_mapping: {
          description:
            "Define the atrtibute name mapping between Identity Provider and Clerk's user properties",
          type: ["object", "null"],
          additionalProperties: false,
          properties: {
            user_id: {
              type: "string",
            },
            email_address: {
              type: "string",
            },
            first_name: {
              type: "string",
            },
            last_name: {
              type: "string",
            },
          },
        },
        active: {
          description: "Activate or de-activate the SAML Connection",
          type: ["boolean", "null"],
        },
        sync_user_attributes: {
          description:
            "Controls whether to update the user's attributes in each sign-in",
          type: ["boolean", "null"],
        },
        allow_subdomains: {
          description:
            "Allow users with an email address subdomain to use this connection in order to authenticate",
          type: ["boolean", "null"],
        },
        allow_idp_initiated: {
          description: "Enable or deactivate IdP-initiated flows",
          type: ["boolean", "null"],
        },
        disable_additional_identifications: {
          description: "Enable or deactivate additional identifications",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
  {
    description: "Retrieve a new testing token.",
    method: "post",
    name: "CreateTestingToken",
    url: "https://api.clerk.com/v1/testing_tokens",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    defs: {},
  },
  {
    description:
      "Retrieves all organization user memberships for the given instance.",
    method: "get",
    name: "InstanceGetOrganizationMemberships",
    url: "https://api.clerk.com/v1/organization_memberships",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Sorts organizations memberships by phone_number, email_address, created_at, first_name, last_name or username.\nBy prepending one of those values with + or -,\nwe can choose to sort in ascending (ASC) or descending (DESC) order.",
        in: "query",
        name: "order_by",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Retrieve a list of waitlist entries for the instance.\nEntries are ordered by creation date in descending order by default.\nSupports filtering by email address or status and pagination with limit and offset parameters.",
    method: "get",
    name: "ListWaitlistEntries",
    url: "https://api.clerk.com/v1/waitlist_entries",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    params: [
      {
        description:
          "Applies a limit to the number of results returned.\nCan be used for paginating the results together with `offset`.",
        in: "query",
        name: "limit",
        required: false,
        explode: true,
        schema: {
          default: 10,
          maximum: 500,
          minimum: 1,
          type: "integer",
        },
        style: "form",
      },
      {
        description:
          "Skip the first `offset` results when paginating.\nNeeds to be an integer greater or equal to zero.\nTo be used in conjunction with `limit`.",
        in: "query",
        name: "offset",
        required: false,
        explode: true,
        schema: {
          default: 0,
          minimum: 0,
          type: "integer",
        },
        style: "form",
      },
      {
        description: "Filter waitlist entries by `email_address` or `id`",
        in: "query",
        name: "query",
        required: false,
        explode: true,
        schema: {
          type: "string",
        },
        style: "form",
      },
      {
        description: "Filter waitlist entries by their status",
        in: "query",
        name: "status",
        required: false,
        explode: true,
        schema: {
          enum: ["pending", "invited", "completed", "rejected"],
          type: "string",
        },
        style: "form",
      },
      {
        description:
          "Specify the order of results. Supported values are:\n- `created_at`\n- `email_address`\n- `invited_at`\n\nUse `+` for ascending or `-` for descending order. Defaults to `-created_at`.",
        in: "query",
        name: "order_by",
        required: false,
        explode: true,
        schema: {
          default: "-created_at",
          type: "string",
        },
        style: "form",
      },
    ],
    defs: {},
  },
  {
    description:
      "Creates a new waitlist entry for the given email address.\nIf the email address is already on the waitlist, no new entry will be created and the existing waitlist entry will be returned.",
    method: "post",
    name: "CreateWaitlistEntry",
    url: "https://api.clerk.com/v1/waitlist_entries",
    auth: [
      {
        bearerFormat: "sk_<environment>_<secret value>",
        description:
          'Secret key, obtained under "API Keys" in the Clerk Dashboard.',
        key: "bearerAuth",
        scheme: "bearer",
        type: "http",
      },
    ],
    body: {
      required: ["email_address"],
      type: "object",
      properties: {
        email_address: {
          description: "The email address to add to the waitlist",
          type: "string",
        },
        notify: {
          default: true,
          description:
            "Optional flag which denotes whether a confirmation email should be sent to the given email address.\nDefaults to `true`.",
          type: ["boolean", "null"],
        },
      },
    },
    contentType: "application/json",
    defs: {},
  },
];