/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
    "/mfa/info": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /** @description Returns information about the auth factors of the current user and refreshes the related session claim
         *      */
        put: operations["getMFAInfo"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/totp/device/list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description List the TOTP devices of the current user
         *      */
        get: operations["listTOTPdevices"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/totp/device": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Creates an unverified totp device
         *      */
        post: operations["createTOTPDevice"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/totp/device/remove": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Removes a totp device
         *      */
        post: operations["removeTOTPDevice"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/totp/device/verify": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Checks that the TOTP sent in the body belongs to the totp device (specified by deviceName, belonging to the session user)
         *      */
        post: operations["verifyTOTPDevice"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/totp/verify": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Checks that the TOTP sent in the body belongs to a verified totp device of the session user
         *      */
        post: operations["verifyTOTP"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/signinup/code": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Start sign in/up process with passwordless
         *      */
        post: operations["passwordlessSignInUpStart"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/signinup/code/resend": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Resend passwordless code
         *      */
        post: operations["passwordlessSignInUpResend"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/signinup/code/consume": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Finish sign in/up process with passwordless
         *      */
        post: operations["passwordlessSignInUpConsume"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/signup/email/exists\u2800\u2800": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * @deprecated
         * @description Check if an email exists
         *     Note that there is an invisible character at the end of the path, this was to avoid a conflict with the OpenAPI spec.
         *
         */
        get: operations["passwordlessEmailExistsDepr"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/passwordless/email/exists": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Check if an email exists
         *      */
        get: operations["passwordlessEmailExists"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/signup/phoneNumber/exists": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * @deprecated
         * @description Check if a phone number exists
         *
         */
        get: operations["passwordlessPhoneNumberExistsDepr"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/passwordless/phonenumber/exists": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Check if a phone number exists
         *      */
        get: operations["passwordlessPhoneNumberExists"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/signout": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Logout user
         *      */
        post: operations["signout"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/session/refresh": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Refresh the user session
         *      */
        post: operations["refresh"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/signin": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Signin a user with email ID and password
         *      */
        post: operations["signIn"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/signup": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Signup a user with email ID and password
         *      */
        post: operations["signUp"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/signup/email/exists": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * @deprecated
         * @description Check if an email exists
         *
         */
        get: operations["emailExistsDepr"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/emailpassword/email/exists": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Check if an email exists
         *      */
        get: operations["emailExists"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/user/password/reset/token": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Generate a new reset password token for this user
         *      */
        post: operations["passwordResetToken"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/user/password/reset": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Reset a password using password reset token
         *      */
        post: operations["passwordReset"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/signinup": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Signin/up a user
         *      */
        post: operations["signInUp"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/authorisationurl": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Get the thirdparty provider's authorisation URL to which the user should be redirected to.
         *      */
        get: operations["authorisationUrl"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/loginmethods": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Get enabled login methods: Returns recipes with their enabled setting and recipe specific configuration.
         *      */
        get: operations["loginmethods"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/callback/apple": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Handles sign in with the apple.
         *      */
        post: operations["thirdPartyCallbackApple"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/user/email/verify/token": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Send email verification email
         *      */
        post: operations["verifyEmailToken"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/<tenantId>/user/email/verify": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** @description Verify an email
         *      */
        post: operations["verifyEmail"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/user/email/verify": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Checks if an email is verified and adds this information into the access token payload as well
         *      */
        get: operations["getVerifyEmail"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/jwt/jwks.json": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Get all JSON web keys for JWT verification
         *      */
        get: operations["getJWKS"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/.well-known/openid-configuration": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Get OpenID discovery configuration
         *      */
        get: operations["getOpenIdDiscoveryConfiguration"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/example": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description API endpoint in your application, checked with `verifySession`
         *      */
        get: operations["exampleAppAPI"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, unknown>;
export interface components {
    schemas: {
        /** @enum {string} */
        statusOK: "OK";
        generalErrorResponse: {
            /** @enum {string} */
            status: "GENERAL_ERROR";
            message?: string;
        };
        /** @example ZTRiOTBjNz...jI5MTZlODkxw */
        token: string;
        /** @example ed3164...06c0d; Path=/; Expires=Thu, 30 Sep 2021 06:43:07 GMT; HttpOnly; SameSite=Lax */
        cookie: string;
        /** @enum {string} */
        id: "email" | "password";
        /** @example fa7a0841-b533-4478-95533-0fde890c3483 */
        userId: string;
        user: {
            id: components["schemas"]["userId"];
            /** @example 1638433545183 */
            timeJoined: number;
            /** @example true */
            isPrimaryUser: boolean;
            tenantIds: string[];
            emails: string[];
            phoneNumbers: string[];
            thirdParty: {
                /** @example google */
                id: string;
                /** @example rq238mrq2389rvq123213 */
                userId: string;
            }[];
            loginMethods: {
                /** @enum {string} */
                recipeId: "emailpassword" | "thirdparty" | "passwordless";
                recipeUserId: components["schemas"]["userId"];
                /** @example true */
                verified?: boolean;
                tenantIds: string[];
                /** @example 1638433545183 */
                timeJoined: number;
                /** @example johndoe@gmail.com */
                email?: string;
                /** @example 36201234123 */
                phoneNumber?: string;
                thirdParty?: {
                    /** @example google */
                    id: string;
                    /** @example rq238mrq2389rvq123213 */
                    userId: string;
                };
            }[];
        };
        /** @example johndoe@gmail.com */
        email: string;
        /** @example 0036701234567 */
        phoneNumber: string;
        /**
         * @description This should be saved on the starting device to enable the manual code entry flow.
         * @example TU/52WOcktSv99zqaAZuWJG9BSoS0aRLfCbep8rFEwk=
         */
        deviceId: string;
        /**
         * @description An identifier that used to identify the login attempt/device.
         * @example kFmkPQEAJtACiT2w/K8fndEuNm+XozJXSZSlWEr+iGs=
         */
        preAuthSessionId: string;
        /** @example google */
        thirdPartyId: string;
        /** @example true */
        exists: boolean;
        /** @example token */
        method: string;
        code: components["schemas"]["token"];
        /** @description Can contain random data other than the two listed below */
        authCodeResponse: {
            access_token: string;
            id_token?: string;
        };
        /** @example https://yourdomain.com/callback */
        redirectURI: string;
        /** @example web */
        clientType: string;
        oAuthTokens: {
            /** @example ZTRiOTBjNz...jI5MTZlODkxw */
            access_token?: string;
            /** @example ZTRiOTBjNz...jI5MTZlODkxw */
            id_token?: string;
        };
        /** @example [
         *       {
         *         "id": "email",
         *         "value": "johndoe@gmail.com"
         *       },
         *       {
         *         "id": "password",
         *         "value": "testPass123"
         *       }
         *     ] */
        formFields: {
            id?: components["schemas"]["id"];
            value?: string;
        }[];
        signInResponse: {
            status: components["schemas"]["statusOK"];
            user?: components["schemas"]["user"];
        };
        signInNotAllowedResponse: {
            /** @enum {string} */
            status: "SIGN_IN_NOT_ALLOWED";
            /** @example Cannot sign in due to security reasons. Please try resetting your password, use a different login method or contact support. (ERR_CODE_008) */
            reason?: string;
        };
        signupResponse: {
            status: components["schemas"]["statusOK"];
            user?: components["schemas"]["user"];
        };
        signUpNotAllowedResponse: {
            /** @enum {string} */
            status: "SIGN_UP_NOT_ALLOWED";
            /** @example Cannot sign up due to security reasons. Please try resetting your password, use a different login method or contact support. (ERR_CODE_007) */
            reason?: string;
        };
        passwordResetTokenResponse: {
            status: components["schemas"]["statusOK"];
        };
        passwordResetNotAllowedResponse: {
            /** @enum {string} */
            status: "PASSWORD_RESET_NOT_ALLOWED";
            /** @example Token generation was not done because of account take over risk. Please contact support. (HAS_OTHER_EMAIL_OR_PHONE) */
            reason?: string;
        };
        signinupResponse: {
            status: components["schemas"]["statusOK"];
            user?: components["schemas"]["user"];
            /** @example true */
            createdNewRecipeUser?: boolean;
        };
        passwordResetErrorResponse: {
            /** @enum {string} */
            status: "RESET_PASSWORD_INVALID_TOKEN_ERROR";
        };
        passwordResetResponse: {
            /** @enum {string} */
            status: "OK";
        };
        fieldErrorResponse: {
            /** @enum {string} */
            status: "FIELD_ERROR";
            formFields: {
                /** @example email */
                id: string;
                /** @example Error Message */
                error: string;
            }[];
        };
        wrongCredentialsResponse: {
            /** @enum {string} */
            status: "WRONG_CREDENTIALS_ERROR";
        };
        signinupErrorResponse:
            | {
                  /** @enum {string} */
                  status: "NO_EMAIL_GIVEN_BY_PROVIDER";
              }
            | {
                  /** @enum {string} */
                  status: "SIGN_IN_UP_NOT_ALLOWED";
                  /** @example Cannot sign in / up due to security reasons. Please contact support. (IS_SIGN_IN_ALLOWED_FALSE) */
                  reason?: string;
              };
        /** @enum {string} */
        internalError: "Internal Error";
        /** @enum {string} */
        badRequest: "Bad request";
        /** @enum {string} */
        notFound: "Not Found";
    };
    responses: {
        /** @description error code 400 */
        400: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "text/plain": components["schemas"]["badRequest"];
            };
        };
        /** @description error code 404 */
        404: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "text/plain": components["schemas"]["notFound"];
            };
        };
        /** @description error code 500 */
        500: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "text/plain": components["schemas"]["internalError"];
            };
        };
        /** @description A claim validation error happened during factor setup */
        "403-factor-setup": {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json":
                    | {
                          /** @example invalid claim */
                          message?: string;
                          claimValidationErrors?: {
                              /** @example st-ev */
                              id?: string;
                              /** @example {
                               *       "message": "wrong value",
                               *       "expectedValue": true,
                               *       "actualValue": false
                               *     } */
                              reason?: Record<string, unknown>;
                          }[];
                      }
                    | {
                          /** @example invalid claim */
                          message?: string;
                          claimValidationErrors?: {
                              /** @example st-mfa */
                              id?: string;
                              /** @example Completed factors in the session does not satisfy the MFA requirements for auth */
                              reason?: string;
                          }[];
                      };
            };
        };
    };
    parameters: {
        /** @example session */
        rid: string;
        /** @example emailpassword */
        emailPasswordRid: string;
        /** @example thirdparty */
        thirdPartyRid: string;
        /** @example passwordless */
        passwordlessRid: string;
        /** @example emailverification */
        emailVerificationRid: string;
        /** @example multitenancy */
        multitenancyRid: string;
        /** @example multifactorauth */
        multiFactorAuthRid: string;
        /** @example totp */
        totpRid: string;
        /** @description This will only be here if enabled by the user. */
        "anti-csrf": components["schemas"]["token"];
        /** @description Its value depends on the apiBasePath set by the user */
        apiBasePath: string;
        email: string;
        phoneNumber: string;
    };
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, unknown>;
export interface operations {
    getMFAInfo: {
        parameters: {
            query?: never;
            header?: {
                /** @example multifactorauth */
                rid?: components["parameters"]["multiFactorAuthRid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Information about the auth factors of the current user and optionally the session with a refreshed MFA claim */
            200: {
                headers: {
                    /** @description Sent in cookie-based sessions if the access token payload is updated */
                    "Set-Cookie"?: string;
                    /** @description Sent in cookie-based sessions if the access token payload is updated */
                    "st-access-token"?: components["schemas"]["token"];
                    /** @description Sent if enabled by the user */
                    "anti-csrf"?: components["schemas"]["token"];
                    /** @description Sent if the access token payload is updated */
                    "front-token"?: components["schemas"]["token"];
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              factors?: {
                                  alreadySetup: string[];
                                  allowedToSetup: string[];
                                  next: string[];
                              };
                              emails?: {
                                  emailpassword?: string[];
                                  "otp-email"?: string[];
                                  "link-email"?: string[];
                              };
                              phoneNumbers?: {
                                  "otp-phone"?: string[];
                                  "link-phone"?: string[];
                              };
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    listTOTPdevices: {
        parameters: {
            query?: never;
            header?: {
                /** @example totp */
                rid?: components["parameters"]["totpRid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The list of the TOTP devices of the session user */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              devices?: {
                                  /** @example asdf123 */
                                  name: string;
                                  /** @example 30 */
                                  period: number;
                                  /** @example 30 */
                                  skew: number;
                                  /** @example false */
                                  verified: boolean;
                              }[];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    createTOTPDevice: {
        parameters: {
            query?: never;
            header?: {
                /** @example totp */
                rid?: components["parameters"]["totpRid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @example asdf123 */
                    deviceName?: string;
                };
            };
        };
        responses: {
            /** @description Information about the created (unverified) device. Based on the this,
             *     the user can add the device to their TOTP app and verify it.
             *      */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              /** @example asfd123 */
                              deviceName?: string;
                              /** @example otpauth://totp/Supertokens:alice@google.com?secret=JBSWY3DPEHPK3PXP&issuer=Supertokens */
                              qrCodeString?: string;
                              /** @example JBSWY3DPEHPK3PXP */
                              secret?: string;
                          }
                        | {
                              /** @enum {string} */
                              status: "DEVICE_ALREADY_EXISTS_ERROR";
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            403: components["responses"]["403-factor-setup"];
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    removeTOTPDevice: {
        parameters: {
            query?: never;
            header?: {
                /** @example totp */
                rid?: components["parameters"]["totpRid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @example asdf123 */
                    deviceName?: string;
                };
            };
        };
        responses: {
            /** @description Success report */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              /** @example true */
                              didDeviceExist?: boolean;
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    verifyTOTPDevice: {
        parameters: {
            query?: never;
            header?: {
                /** @example totp */
                rid?: components["parameters"]["totpRid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @example 123456 */
                    totp?: string;
                    /** @example asdf123asdf */
                    deviceName?: string;
                };
            };
        };
        responses: {
            /** @description Verification result and optionally the session with a refreshed MFA claim */
            200: {
                headers: {
                    /** @description Sent in cookie-based sessions if the access token payload is updated */
                    "Set-Cookie"?: string;
                    /** @description Sent in cookie-based sessions if the access token payload is updated */
                    "st-access-token"?: components["schemas"]["token"];
                    /** @description Sent if enabled by the user */
                    "anti-csrf"?: components["schemas"]["token"];
                    /** @description Sent if the access token payload is updated */
                    "front-token"?: components["schemas"]["token"];
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              wasAlreadyVerified: boolean;
                          }
                        | {
                              /** @enum {string} */
                              status: "UNKNOWN_DEVICE_ERROR";
                          }
                        | {
                              /** @enum {string} */
                              status: "INVALID_TOTP_ERROR";
                              /** @example 2 */
                              currentNumberOfFailedAttempts?: number;
                              /** @example 5 */
                              maxNumberOfFailedAttempts?: number;
                          }
                        | {
                              /** @enum {string} */
                              status: "LIMIT_REACHED_ERROR";
                              /** @example 30000 */
                              retryAfterMs?: number;
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            403: components["responses"]["403-factor-setup"];
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    verifyTOTP: {
        parameters: {
            query?: never;
            header?: {
                /** @example totp */
                rid?: components["parameters"]["totpRid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @example 123456 */
                    totp?: string;
                };
            };
        };
        responses: {
            /** @description Verification result and optionally the session with a refreshed MFA claim */
            200: {
                headers: {
                    /** @description Sent in cookie-based sessions if the access token payload is updated */
                    "Set-Cookie"?: string;
                    /** @description Sent in cookie-based sessions if the access token payload is updated */
                    "st-access-token"?: components["schemas"]["token"];
                    /** @description Sent if enabled by the user */
                    "anti-csrf"?: components["schemas"]["token"];
                    /** @description Sent if the access token payload is updated */
                    "front-token"?: components["schemas"]["token"];
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                          }
                        | {
                              /** @enum {string} */
                              status: "INVALID_TOTP_ERROR";
                              /** @example 2 */
                              currentNumberOfFailedAttempts?: number;
                              /** @example 5 */
                              maxNumberOfFailedAttempts?: number;
                          }
                        | {
                              /** @enum {string} */
                              status: "LIMIT_REACHED_ERROR";
                              /** @example 30000 */
                              retryAfterMs?: number;
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    passwordlessSignInUpStart: {
        parameters: {
            query?: never;
            header?: {
                /** @example passwordless */
                rid?: components["parameters"]["passwordlessRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json":
                    | {
                          email: components["schemas"]["email"];
                          /** @example false */
                          shouldTryLinkingWithSessionUser?: boolean;
                      }
                    | {
                          phoneNumber: components["schemas"]["phoneNumber"];
                          /** @example false */
                          shouldTryLinkingWithSessionUser?: boolean;
                      };
            };
        };
        responses: {
            /** @description Started the passwordless sign in/up process. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              deviceId?: components["schemas"]["deviceId"];
                              preAuthSessionId?: components["schemas"]["preAuthSessionId"];
                              /** @enum {string} */
                              flowType?: "MAGIC_LINK" | "USER_INPUT_CODE_AND_MAGIC_LINK" | "USER_INPUT_CODE";
                          }
                        | {
                              /** @enum {string} */
                              status: "SIGN_IN_UP_NOT_ALLOWED";
                              /** @example Cannot sign in / up due to security reasons. Please contact support. (IS_SIGN_IN_ALLOWED_FALSE) */
                              reason?: string;
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            403: components["responses"]["403-factor-setup"];
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    passwordlessSignInUpResend: {
        parameters: {
            query?: never;
            header?: {
                /** @example passwordless */
                rid?: components["parameters"]["passwordlessRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    deviceId: components["schemas"]["deviceId"];
                    preAuthSessionId: components["schemas"]["preAuthSessionId"];
                    /** @example false */
                    shouldTryLinkingWithSessionUser?: boolean;
                };
            };
        };
        responses: {
            /** @description Started the passwordless sign in/up process. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              /** @enum {string} */
                              status: "OK" | "RESTART_FLOW_ERROR";
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    passwordlessSignInUpConsume: {
        parameters: {
            query?: never;
            header?: {
                /** @example passwordless */
                rid?: components["parameters"]["passwordlessRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json":
                    | {
                          preAuthSessionId: components["schemas"]["preAuthSessionId"];
                          /** @example false */
                          shouldTryLinkingWithSessionUser?: boolean;
                          /** @example b10lbT_SnDC4flA6Fn7pE5TtG5k5NfigLef4QMBeGA8 */
                          linkCode: string;
                      }
                    | {
                          preAuthSessionId: components["schemas"]["preAuthSessionId"];
                          /** @example false */
                          shouldTryLinkingWithSessionUser?: boolean;
                          deviceId: components["schemas"]["deviceId"];
                          /** @example 432123 */
                          userInputCode: string;
                      };
            };
        };
        responses: {
            /** @description Signin/up a user */
            200: {
                headers: {
                    /** @description In cookie-based sessions */
                    "Set-Cookie"?: string;
                    /** @description In header-based sessions */
                    "st-access-token"?: components["schemas"]["token"];
                    /** @description In header-based sessions */
                    "st-refresh-token"?: components["schemas"]["token"];
                    /** @description If enabled by the user */
                    "anti-csrf"?: components["schemas"]["token"];
                    "front-token"?: components["schemas"]["token"];
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              /** @example true */
                              createdNewRecipeUser?: boolean;
                              user?: components["schemas"]["user"];
                          }
                        | {
                              /** @enum {string} */
                              status: "INCORRECT_USER_INPUT_CODE_ERROR" | "EXPIRED_USER_INPUT_CODE_ERROR";
                              /** @example 2 */
                              failedCodeInputAttemptCount?: number;
                              /** @example 5 */
                              maximumCodeInputAttempts?: number;
                          }
                        | {
                              /** @enum {string} */
                              status: "RESTART_FLOW_ERROR";
                          }
                        | {
                              /** @enum {string} */
                              status: "SIGN_IN_UP_NOT_ALLOWED";
                              /** @example Cannot sign in / up due to security reasons. Please contact support. (IS_SIGN_IN_ALLOWED_FALSE) */
                              reason?: string;
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            403: components["responses"]["403-factor-setup"];
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    passwordlessEmailExistsDepr: {
        parameters: {
            query: {
                email: components["parameters"]["email"];
            };
            header?: {
                /** @example passwordless */
                rid?: components["parameters"]["passwordlessRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Checks if an email exists */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              exists?: components["schemas"]["exists"];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    passwordlessEmailExists: {
        parameters: {
            query: {
                email: components["parameters"]["email"];
            };
            header?: {
                /** @example passwordless */
                rid?: components["parameters"]["passwordlessRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Checks if an email exists */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              exists?: components["schemas"]["exists"];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    passwordlessPhoneNumberExistsDepr: {
        parameters: {
            query: {
                phoneNumber: components["parameters"]["phoneNumber"];
            };
            header?: {
                /** @example passwordless */
                rid?: components["parameters"]["passwordlessRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Checks if a phone number exists */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              exists?: components["schemas"]["exists"];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    passwordlessPhoneNumberExists: {
        parameters: {
            query: {
                phoneNumber: components["parameters"]["phoneNumber"];
            };
            header?: {
                /** @example passwordless */
                rid?: components["parameters"]["passwordlessRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Checks if a phone number exists */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              exists?: components["schemas"]["exists"];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    signout: {
        parameters: {
            query?: never;
            header?: {
                /** @example session */
                rid?: components["parameters"]["rid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": Record<string, unknown>;
            };
        };
        responses: {
            /** @description Logout user */
            200: {
                headers: {
                    "Set-Cookie"?: string;
                    /** @description Set to an empty string to trigger token clearing in the client SDK */
                    "st-access-token"?: string;
                    /** @description Set to an empty string to trigger token clearing in the client SDK */
                    "st-refresh-token"?: string;
                    "front-token"?: string;
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    refresh: {
        parameters: {
            query?: never;
            header?: {
                /** @example session */
                rid?: components["parameters"]["rid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Refresh users */
            200: {
                headers: {
                    /** @description In cookie-based sessions */
                    "Set-Cookie"?: string;
                    /** @description In header-based sessions */
                    "st-access-token"?: components["schemas"]["token"];
                    /** @description In header-based sessions */
                    "st-refresh-token"?: components["schemas"]["token"];
                    /** @description If enabled by the user */
                    "anti-csrf"?: components["schemas"]["token"];
                    "front-token"?: components["schemas"]["token"];
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content?: never;
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    signIn: {
        parameters: {
            query?: never;
            header?: {
                /** @example session */
                rid?: components["parameters"]["rid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    formFields: components["schemas"]["formFields"];
                    /** @example false */
                    shouldTryLinkingWithSessionUser?: boolean;
                };
            };
        };
        responses: {
            /** @description Sign in Response */
            200: {
                headers: {
                    /** @description In cookie-based sessions */
                    "Set-Cookie"?: string;
                    /** @description In header-based sessions */
                    "st-access-token"?: components["schemas"]["token"];
                    /** @description In header-based sessions */
                    "st-refresh-token"?: components["schemas"]["token"];
                    /** @description If enabled by the user */
                    "anti-csrf"?: components["schemas"]["token"];
                    "front-token"?: components["schemas"]["token"];
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | components["schemas"]["signInResponse"]
                        | components["schemas"]["signInNotAllowedResponse"]
                        | components["schemas"]["fieldErrorResponse"]
                        | components["schemas"]["wrongCredentialsResponse"]
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            403: components["responses"]["403-factor-setup"];
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    signUp: {
        parameters: {
            query?: never;
            header?: {
                /** @example emailpassword */
                rid?: components["parameters"]["emailPasswordRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    formFields: components["schemas"]["formFields"];
                    /** @example false */
                    shouldTryLinkingWithSessionUser?: boolean;
                };
            };
        };
        responses: {
            /** @description Sign up Response */
            200: {
                headers: {
                    /** @description In cookie-based sessions */
                    "Set-Cookie"?: string;
                    /** @description In header-based sessions */
                    "st-access-token"?: components["schemas"]["token"];
                    /** @description In header-based sessions */
                    "st-refresh-token"?: components["schemas"]["token"];
                    /** @description If enabled by the user */
                    "anti-csrf"?: components["schemas"]["token"];
                    "front-token"?: components["schemas"]["token"];
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | components["schemas"]["signupResponse"]
                        | components["schemas"]["signUpNotAllowedResponse"]
                        | components["schemas"]["fieldErrorResponse"]
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            403: components["responses"]["403-factor-setup"];
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    emailExistsDepr: {
        parameters: {
            query: {
                email: components["parameters"]["email"];
            };
            header?: {
                /** @example emailpassword */
                rid?: components["parameters"]["emailPasswordRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Checks if an email exists */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              exists?: components["schemas"]["exists"];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    emailExists: {
        parameters: {
            query: {
                email: components["parameters"]["email"];
            };
            header?: {
                /** @example emailpassword */
                rid?: components["parameters"]["emailPasswordRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Checks if an email exists */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              exists?: components["schemas"]["exists"];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    passwordResetToken: {
        parameters: {
            query?: never;
            header?: {
                /** @example emailpassword */
                rid?: components["parameters"]["emailPasswordRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    formFields?: components["schemas"]["formFields"];
                };
            };
        };
        responses: {
            /** @description Generate a new reset password token for this user */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | components["schemas"]["passwordResetTokenResponse"]
                        | components["schemas"]["passwordResetNotAllowedResponse"]
                        | components["schemas"]["fieldErrorResponse"]
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    passwordReset: {
        parameters: {
            query?: never;
            header?: {
                /** @example emailpassword */
                rid?: components["parameters"]["emailPasswordRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    method?: components["schemas"]["method"];
                    formfields?: components["schemas"]["formFields"];
                    token?: components["schemas"]["token"];
                };
            };
        };
        responses: {
            /** @description Reset a password using password reset token */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | components["schemas"]["passwordResetResponse"]
                        | components["schemas"]["passwordResetErrorResponse"]
                        | components["schemas"]["fieldErrorResponse"]
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    signInUp: {
        parameters: {
            query?: never;
            header?: {
                /** @example thirdparty */
                rid?: components["parameters"]["thirdPartyRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json":
                    | {
                          thirdPartyId: components["schemas"]["thirdPartyId"];
                          clientType?: components["schemas"]["clientType"];
                          redirectURIInfo: {
                              redirectURIOnProviderDashboard: components["schemas"]["redirectURI"];
                              /** @example {
                               *       "code": "neqmpdsfuqe141m5lk437867masdf",
                               *       "state": "ljayfgqewertbh13245njw0"
                               *     } */
                              redirectURIQueryParams: Record<string, unknown>;
                              /** @example abcd1234 */
                              pkceCodeVerifier?: string;
                          };
                          /** @example false */
                          shouldTryLinkingWithSessionUser?: boolean;
                      }
                    | {
                          thirdPartyId: components["schemas"]["thirdPartyId"];
                          clientType?: components["schemas"]["clientType"];
                          oAuthTokens: components["schemas"]["oAuthTokens"];
                          /** @example false */
                          shouldTryLinkingWithSessionUser?: boolean;
                      };
            };
        };
        responses: {
            /** @description Signin/up a user */
            200: {
                headers: {
                    /** @description In cookie-based sessions */
                    "Set-Cookie"?: string;
                    /** @description In header-based sessions */
                    "st-access-token"?: components["schemas"]["token"];
                    /** @description In header-based sessions */
                    "st-refresh-token"?: components["schemas"]["token"];
                    /** @description If enabled by the user */
                    "anti-csrf"?: components["schemas"]["token"];
                    "front-token"?: components["schemas"]["token"];
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | components["schemas"]["signinupResponse"]
                        | components["schemas"]["signinupErrorResponse"]
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            403: components["responses"]["403-factor-setup"];
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    authorisationUrl: {
        parameters: {
            query: {
                thirdPartyId: components["schemas"]["thirdPartyId"];
                redirectURIOnProviderDashboard: components["schemas"]["redirectURI"];
                clientType?: components["schemas"]["clientType"];
            };
            header?: {
                /** @example thirdparty */
                rid?: components["parameters"]["thirdPartyRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Get the OAuth authorisation URL */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              /** @example https://providerdomain.com/authorize?client_id=..&scope=..&access_type=.. */
                              urlWithQueryParams?: string;
                              /** @example abcd1234 */
                              pkceCodeVerifier?: string;
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    loginmethods: {
        parameters: {
            query?: {
                clientType?: components["schemas"]["clientType"];
            };
            header?: {
                /** @example multitenancy */
                rid?: components["parameters"]["multitenancyRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Get enabled login methods */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              emailPassword: {
                                  /** @example true */
                                  enabled: boolean;
                              };
                              thirdParty: {
                                  /** @example true */
                                  enabled: boolean;
                                  providers: {
                                      id: components["schemas"]["thirdPartyId"];
                                      /** @example Google */
                                      name: string;
                                  }[];
                              };
                              passwordless: {
                                  /** @example true */
                                  enabled: boolean;
                              };
                              firstFactors: string[];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    thirdPartyCallbackApple: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/x-www-form-urlencoded": {
                    /** @description The Authorization code which will be exchanged for an access token */
                    code?: string;
                    /** @description A unique string used to mitigate CSRF attacks */
                    state?: string;
                };
            };
        };
        responses: {
            /** @description Redirects the user to the client's app. */
            303: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    verifyEmailToken: {
        parameters: {
            query?: never;
            header?: {
                /** @example emailverification */
                rid?: components["parameters"]["emailVerificationRid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Send email verification email */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              /** @enum {string} */
                              status: "OK" | "EMAIL_ALREADY_VERIFIED_ERROR";
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    verifyEmail: {
        parameters: {
            query?: never;
            header?: {
                /** @example emailverification */
                rid?: components["parameters"]["emailVerificationRid"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    method?: components["schemas"]["method"];
                    token?: components["schemas"]["token"];
                };
            };
        };
        responses: {
            /** @description Verify an email */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              /** @enum {string} */
                              status: "OK" | "EMAIL_VERIFICATION_INVALID_TOKEN_ERROR";
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    getVerifyEmail: {
        parameters: {
            query?: never;
            header?: {
                /** @example emailverification */
                rid?: components["parameters"]["emailVerificationRid"];
                /** @description This will only be here if enabled by the user. */
                "anti-csrf"?: components["parameters"]["anti-csrf"];
            };
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Checks if an email is verified and adds this information into the access token payload as well */
            200: {
                headers: {
                    /** @description Sent in cookie-based sessions if the access token payload is updated */
                    "Set-Cookie"?: string;
                    /** @description Sent in cookie-based sessions if the access token payload is updated */
                    "st-access-token"?: components["schemas"]["token"];
                    /** @description Sent if enabled by the user */
                    "anti-csrf"?: components["schemas"]["token"];
                    /** @description Sent if the access token payload is updated */
                    "front-token"?: components["schemas"]["token"];
                    "Access-Control-Expose-Headers"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              status: components["schemas"]["statusOK"];
                              /** @example true */
                              isVerified?: boolean;
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    getJWKS: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Retrieve JWKs for JWT verification */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              keys?: {
                                  /**
                                   * @description The algorithm to use when creating the JWT.
                                   * @enum {string}
                                   */
                                  alg?: "RS256";
                                  /** @example RSA */
                                  kty?: string;
                                  /** @example sig */
                                  use?: string;
                                  /** @description Unique identifier for the JWK */
                                  kid?: string;
                                  /** @description Modulus for the key */
                                  n?: string;
                                  /** @description Exponent for the key */
                                  e?: string;
                              }[];
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            400: components["responses"]["400"];
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    getOpenIdDiscoveryConfiguration: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Retrieve OpenID configuration */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json":
                        | {
                              /**
                               * @description URL using the https scheme with no query or fragment component that the OP asserts as its Issuer Identifier (https://openid.net/specs/openid-connect-discovery-1_0.html section 3)
                               * @example https://api.example.com/auth
                               */
                              issuer?: string;
                              /**
                               * @description URL for fetching a list JsonWebKey, used for JWT signature verification. Refer to /jwt/jwks.json API in the JWT recipe for JWK details
                               * @example https://api.example.com/auth/jwt/jwks.json
                               */
                              jwks_uri?: string;
                          }
                        | components["schemas"]["generalErrorResponse"];
                };
            };
            400: components["responses"]["400"];
            404: components["responses"]["404"];
            500: components["responses"]["500"];
        };
    };
    exampleAppAPI: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Its value depends on the apiBasePath set by the user */
                apiBasePath: components["parameters"]["apiBasePath"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The session passed verification and went through the application code */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description The session doesn't exists or if it needs to be refreshed */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /**
                         * @description unauthorised or try refresh token
                         * @example try refresh token
                         */
                        message?: string;
                    };
                };
            };
            /** @description The session exists, but didn't pass a claim validator */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @example invalid claim */
                        message?: string;
                        claimValidationErrors?: {
                            /** @example st-ev */
                            id?: string;
                            /** @example {
                             *       "message": "value does not exist",
                             *       "expectedValue": "val",
                             *       "actualValue": "claimVal"
                             *     } */
                            reason?: Record<string, unknown>;
                        }[];
                    };
                };
            };
        };
    };
}