@tinyrack/tinyauth-server 0.0.7

package/dist/schemas/error.d.ts

@@ -0,0 +1,2104 @@
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+import { z } from 'zod';
+export declare class TinyAuthError<STATUS extends ContentfulStatusCode = ContentfulStatusCode, CODE extends string = string, MESSAGE extends string = string> extends Error {
+    readonly status: STATUS;
+    readonly code: CODE;
+    readonly message: MESSAGE;
+    constructor(status: STATUS, code: CODE, message: MESSAGE);
+    toJson(): {
+        code: CODE;
+        message: MESSAGE;
+    };
+}
+export declare const e: {
+    InvalidEmailOrPassword: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "INVALID_EMAIL_OR_PASSWORD";
+                readonly message: "The provided email or password is incorrect.";
+                toJson(): {
+                    code: "INVALID_EMAIL_OR_PASSWORD";
+                    message: "The provided email or password is incorrect.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_EMAIL_OR_PASSWORD">;
+            message: z.ZodLiteral<"The provided email or password is incorrect.">;
+        }, z.core.$strip>;
+    };
+    EmailAlreadyExists: {
+        Status: 409;
+        Error: {
+            new (): {
+                readonly status: 409;
+                readonly code: "EMAIL_ALREADY_EXISTS";
+                readonly message: "The provided email is already registered.";
+                toJson(): {
+                    code: "EMAIL_ALREADY_EXISTS";
+                    message: "The provided email is already registered.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"EMAIL_ALREADY_EXISTS">;
+            message: z.ZodLiteral<"The provided email is already registered.">;
+        }, z.core.$strip>;
+    };
+    RegistrationDisabled: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "REGISTRATION_DISABLED";
+                readonly message: "Public registration is disabled.";
+                toJson(): {
+                    code: "REGISTRATION_DISABLED";
+                    message: "Public registration is disabled.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"REGISTRATION_DISABLED">;
+            message: z.ZodLiteral<"Public registration is disabled.">;
+        }, z.core.$strip>;
+    };
+    RegistrationEmailNotAllowed: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "REGISTRATION_EMAIL_NOT_ALLOWED";
+                readonly message: "This email address is not allowed for registration.";
+                toJson(): {
+                    code: "REGISTRATION_EMAIL_NOT_ALLOWED";
+                    message: "This email address is not allowed for registration.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"REGISTRATION_EMAIL_NOT_ALLOWED">;
+            message: z.ZodLiteral<"This email address is not allowed for registration.">;
+        }, z.core.$strip>;
+    };
+    ValidationError: {
+        Status: 400;
+        Error: {
+            new (data: string): {
+                data: string;
+                toJson(): {
+                    data: string;
+                    code: "VALIDATION_ERROR";
+                    message: "The provided data is invalid.";
+                };
+                readonly status: 400;
+                readonly code: "VALIDATION_ERROR";
+                readonly message: "The provided data is invalid.";
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"VALIDATION_ERROR">;
+            message: z.ZodLiteral<"The provided data is invalid.">;
+            data: z.ZodString;
+        }, z.core.$strip>;
+    };
+    InternalServerError: {
+        Status: 500;
+        Error: {
+            new (): {
+                readonly status: 500;
+                readonly code: "INTERNAL_SERVER_ERROR";
+                readonly message: "An unexpected error occurred.";
+                toJson(): {
+                    code: "INTERNAL_SERVER_ERROR";
+                    message: "An unexpected error occurred.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INTERNAL_SERVER_ERROR">;
+            message: z.ZodLiteral<"An unexpected error occurred.">;
+        }, z.core.$strip>;
+    };
+    InvalidVerificationToken: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_VERIFICATION_TOKEN";
+                readonly message: "The verification token is invalid or has expired.";
+                toJson(): {
+                    code: "INVALID_VERIFICATION_TOKEN";
+                    message: "The verification token is invalid or has expired.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_VERIFICATION_TOKEN">;
+            message: z.ZodLiteral<"The verification token is invalid or has expired.">;
+        }, z.core.$strip>;
+    };
+    EmailNotActivated: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "EMAIL_NOT_ACTIVATED";
+                readonly message: "The email service not activated.";
+                toJson(): {
+                    code: "EMAIL_NOT_ACTIVATED";
+                    message: "The email service not activated.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"EMAIL_NOT_ACTIVATED">;
+            message: z.ZodLiteral<"The email service not activated.">;
+        }, z.core.$strip>;
+    };
+    EmailAlreadyVerified: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "EMAIL_ALREADY_VERIFIED";
+                readonly message: "The email address is already verified.";
+                toJson(): {
+                    code: "EMAIL_ALREADY_VERIFIED";
+                    message: "The email address is already verified.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"EMAIL_ALREADY_VERIFIED">;
+            message: z.ZodLiteral<"The email address is already verified.">;
+        }, z.core.$strip>;
+    };
+    UserNotFound: {
+        Status: 404;
+        Error: {
+            new (): {
+                readonly status: 404;
+                readonly code: "USER_NOT_FOUND";
+                readonly message: "User not found.";
+                toJson(): {
+                    code: "USER_NOT_FOUND";
+                    message: "User not found.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"USER_NOT_FOUND">;
+            message: z.ZodLiteral<"User not found.">;
+        }, z.core.$strip>;
+    };
+    OAuthClientNotFound: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "OAUTH_CLIENT_NOT_FOUND";
+                readonly message: "The OAuth client was not found.";
+                toJson(): {
+                    code: "OAUTH_CLIENT_NOT_FOUND";
+                    message: "The OAuth client was not found.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_CLIENT_NOT_FOUND">;
+            message: z.ZodLiteral<"The OAuth client was not found.">;
+        }, z.core.$strip>;
+    };
+    OAuthClientDisabled: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "OAUTH_CLIENT_DISABLED";
+                readonly message: "The OAuth client is disabled.";
+                toJson(): {
+                    code: "OAUTH_CLIENT_DISABLED";
+                    message: "The OAuth client is disabled.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_CLIENT_DISABLED">;
+            message: z.ZodLiteral<"The OAuth client is disabled.">;
+        }, z.core.$strip>;
+    };
+    InvalidRedirectUri: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_REDIRECT_URI";
+                readonly message: "The redirect URI is not registered for this client.";
+                toJson(): {
+                    code: "INVALID_REDIRECT_URI";
+                    message: "The redirect URI is not registered for this client.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_REDIRECT_URI">;
+            message: z.ZodLiteral<"The redirect URI is not registered for this client.">;
+        }, z.core.$strip>;
+    };
+    UnsupportedResponseType: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "UNSUPPORTED_RESPONSE_TYPE";
+                readonly message: "The response type is not supported for this client.";
+                toJson(): {
+                    code: "UNSUPPORTED_RESPONSE_TYPE";
+                    message: "The response type is not supported for this client.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"UNSUPPORTED_RESPONSE_TYPE">;
+            message: z.ZodLiteral<"The response type is not supported for this client.">;
+        }, z.core.$strip>;
+    };
+    InvalidScope: {
+        Status: 400;
+        Error: {
+            new (data: {
+                invalidScopes: string[];
+            }): {
+                data: {
+                    invalidScopes: string[];
+                };
+                toJson(): {
+                    data: {
+                        invalidScopes: string[];
+                    };
+                    code: "INVALID_SCOPE";
+                    message: "One or more requested scopes are invalid.";
+                };
+                readonly status: 400;
+                readonly code: "INVALID_SCOPE";
+                readonly message: "One or more requested scopes are invalid.";
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_SCOPE">;
+            message: z.ZodLiteral<"One or more requested scopes are invalid.">;
+            data: z.ZodObject<{
+                invalidScopes: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    };
+    InvalidCodeChallengeMethod: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_CODE_CHALLENGE_METHOD";
+                readonly message: "The code challenge method must be S256 or plain.";
+                toJson(): {
+                    code: "INVALID_CODE_CHALLENGE_METHOD";
+                    message: "The code challenge method must be S256 or plain.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_CODE_CHALLENGE_METHOD">;
+            message: z.ZodLiteral<"The code challenge method must be S256 or plain.">;
+        }, z.core.$strip>;
+    };
+    OAuthServerError: {
+        Status: 500;
+        Error: {
+            new (): {
+                readonly status: 500;
+                readonly code: "OAUTH_SERVER_ERROR";
+                readonly message: "An unexpected error occurred during OAuth authorization.";
+                toJson(): {
+                    code: "OAUTH_SERVER_ERROR";
+                    message: "An unexpected error occurred during OAuth authorization.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_SERVER_ERROR">;
+            message: z.ZodLiteral<"An unexpected error occurred during OAuth authorization.">;
+        }, z.core.$strip>;
+    };
+    MissingAuthorizationCode: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "MISSING_AUTHORIZATION_CODE";
+                readonly message: "Missing authorization code.";
+                toJson(): {
+                    code: "MISSING_AUTHORIZATION_CODE";
+                    message: "Missing authorization code.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"MISSING_AUTHORIZATION_CODE">;
+            message: z.ZodLiteral<"Missing authorization code.">;
+        }, z.core.$strip>;
+    };
+    MissingRedirectUri: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "MISSING_REDIRECT_URI";
+                readonly message: "Missing redirect_uri.";
+                toJson(): {
+                    code: "MISSING_REDIRECT_URI";
+                    message: "Missing redirect_uri.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"MISSING_REDIRECT_URI">;
+            message: z.ZodLiteral<"Missing redirect_uri.">;
+        }, z.core.$strip>;
+    };
+    MissingCodeVerifier: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "MISSING_CODE_VERIFIER";
+                readonly message: "Missing code_verifier for PKCE.";
+                toJson(): {
+                    code: "MISSING_CODE_VERIFIER";
+                    message: "Missing code_verifier for PKCE.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"MISSING_CODE_VERIFIER">;
+            message: z.ZodLiteral<"Missing code_verifier for PKCE.">;
+        }, z.core.$strip>;
+    };
+    MissingRefreshToken: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "MISSING_REFRESH_TOKEN";
+                readonly message: "Missing refresh_token.";
+                toJson(): {
+                    code: "MISSING_REFRESH_TOKEN";
+                    message: "Missing refresh_token.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"MISSING_REFRESH_TOKEN">;
+            message: z.ZodLiteral<"Missing refresh_token.">;
+        }, z.core.$strip>;
+    };
+    InvalidAuthorizationCode: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_AUTHORIZATION_CODE";
+                readonly message: "Invalid or expired authorization code.";
+                toJson(): {
+                    code: "INVALID_AUTHORIZATION_CODE";
+                    message: "Invalid or expired authorization code.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_AUTHORIZATION_CODE">;
+            message: z.ZodLiteral<"Invalid or expired authorization code.">;
+        }, z.core.$strip>;
+    };
+    RedirectUriMismatch: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "REDIRECT_URI_MISMATCH";
+                readonly message: "Redirect URI mismatch.";
+                toJson(): {
+                    code: "REDIRECT_URI_MISMATCH";
+                    message: "Redirect URI mismatch.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"REDIRECT_URI_MISMATCH">;
+            message: z.ZodLiteral<"Redirect URI mismatch.">;
+        }, z.core.$strip>;
+    };
+    InvalidPKCEVerifier: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_PKCE_VERIFIER";
+                readonly message: "Invalid PKCE code_verifier.";
+                toJson(): {
+                    code: "INVALID_PKCE_VERIFIER";
+                    message: "Invalid PKCE code_verifier.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_PKCE_VERIFIER">;
+            message: z.ZodLiteral<"Invalid PKCE code_verifier.">;
+        }, z.core.$strip>;
+    };
+    InvalidRefreshToken: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_REFRESH_TOKEN";
+                readonly message: "Invalid or expired refresh token.";
+                toJson(): {
+                    code: "INVALID_REFRESH_TOKEN";
+                    message: "Invalid or expired refresh token.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_REFRESH_TOKEN">;
+            message: z.ZodLiteral<"Invalid or expired refresh token.">;
+        }, z.core.$strip>;
+    };
+    ClientIdMismatch: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "CLIENT_ID_MISMATCH";
+                readonly message: "Client ID mismatch.";
+                toJson(): {
+                    code: "CLIENT_ID_MISMATCH";
+                    message: "Client ID mismatch.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"CLIENT_ID_MISMATCH">;
+            message: z.ZodLiteral<"Client ID mismatch.">;
+        }, z.core.$strip>;
+    };
+    InvalidClientCredentials: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "INVALID_CLIENT_CREDENTIALS";
+                readonly message: "Invalid client credentials.";
+                toJson(): {
+                    code: "INVALID_CLIENT_CREDENTIALS";
+                    message: "Invalid client credentials.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_CLIENT_CREDENTIALS">;
+            message: z.ZodLiteral<"Invalid client credentials.">;
+        }, z.core.$strip>;
+    };
+    UnsupportedGrantType: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "UNSUPPORTED_GRANT_TYPE";
+                readonly message: "Grant type is not supported.";
+                toJson(): {
+                    code: "UNSUPPORTED_GRANT_TYPE";
+                    message: "Grant type is not supported.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"UNSUPPORTED_GRANT_TYPE">;
+            message: z.ZodLiteral<"Grant type is not supported.">;
+        }, z.core.$strip>;
+    };
+    InvalidAccessToken: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "INVALID_ACCESS_TOKEN";
+                readonly message: "Invalid or expired access token.";
+                toJson(): {
+                    code: "INVALID_ACCESS_TOKEN";
+                    message: "Invalid or expired access token.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_ACCESS_TOKEN">;
+            message: z.ZodLiteral<"Invalid or expired access token.">;
+        }, z.core.$strip>;
+    };
+    InvalidIdToken: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "INVALID_ID_TOKEN";
+                readonly message: "Invalid or expired ID token.";
+                toJson(): {
+                    code: "INVALID_ID_TOKEN";
+                    message: "Invalid or expired ID token.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_ID_TOKEN">;
+            message: z.ZodLiteral<"Invalid or expired ID token.">;
+        }, z.core.$strip>;
+    };
+    MissingAuthorizationHeader: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "MISSING_AUTHORIZATION_HEADER";
+                readonly message: "Missing Authorization header.";
+                toJson(): {
+                    code: "MISSING_AUTHORIZATION_HEADER";
+                    message: "Missing Authorization header.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"MISSING_AUTHORIZATION_HEADER">;
+            message: z.ZodLiteral<"Missing Authorization header.">;
+        }, z.core.$strip>;
+    };
+    InvalidAuthorizationHeaderFormat: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "INVALID_AUTHORIZATION_HEADER_FORMAT";
+                readonly message: "Invalid Authorization header format. Expected: Bearer <token>";
+                toJson(): {
+                    code: "INVALID_AUTHORIZATION_HEADER_FORMAT";
+                    message: "Invalid Authorization header format. Expected: Bearer <token>";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_AUTHORIZATION_HEADER_FORMAT">;
+            message: z.ZodLiteral<"Invalid Authorization header format. Expected: Bearer <token>">;
+        }, z.core.$strip>;
+    };
+    MissingBearerToken: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "MISSING_BEARER_TOKEN";
+                readonly message: "Missing token in Authorization header.";
+                toJson(): {
+                    code: "MISSING_BEARER_TOKEN";
+                    message: "Missing token in Authorization header.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"MISSING_BEARER_TOKEN">;
+            message: z.ZodLiteral<"Missing token in Authorization header.">;
+        }, z.core.$strip>;
+    };
+    InvalidCodeVerifierLength: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_CODE_VERIFIER_LENGTH";
+                readonly message: "Code verifier length must be between 43 and 128 characters.";
+                toJson(): {
+                    code: "INVALID_CODE_VERIFIER_LENGTH";
+                    message: "Code verifier length must be between 43 and 128 characters.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_CODE_VERIFIER_LENGTH">;
+            message: z.ZodLiteral<"Code verifier length must be between 43 and 128 characters.">;
+        }, z.core.$strip>;
+    };
+    MissingToken: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "MISSING_TOKEN";
+                readonly message: "Missing token parameter.";
+                toJson(): {
+                    code: "MISSING_TOKEN";
+                    message: "Missing token parameter.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"MISSING_TOKEN">;
+            message: z.ZodLiteral<"Missing token parameter.">;
+        }, z.core.$strip>;
+    };
+    ConsentRequired: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "consent_required";
+                readonly message: "The Authorization Server requires End-User consent.";
+                toJson(): {
+                    code: "consent_required";
+                    message: "The Authorization Server requires End-User consent.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"consent_required">;
+            message: z.ZodLiteral<"The Authorization Server requires End-User consent.">;
+        }, z.core.$strip>;
+    };
+    LoginRequired: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "login_required";
+                readonly message: "The Authorization Server requires End-User authentication.";
+                toJson(): {
+                    code: "login_required";
+                    message: "The Authorization Server requires End-User authentication.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"login_required">;
+            message: z.ZodLiteral<"The Authorization Server requires End-User authentication.">;
+        }, z.core.$strip>;
+    };
+    AccessDenied: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "access_denied";
+                readonly message: "The resource owner or authorization server denied the request.";
+                toJson(): {
+                    code: "access_denied";
+                    message: "The resource owner or authorization server denied the request.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"access_denied">;
+            message: z.ZodLiteral<"The resource owner or authorization server denied the request.">;
+        }, z.core.$strip>;
+    };
+    InteractionRequired: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "interaction_required";
+                readonly message: "The Authorization Server requires End-User interaction.";
+                toJson(): {
+                    code: "interaction_required";
+                    message: "The Authorization Server requires End-User interaction.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"interaction_required">;
+            message: z.ZodLiteral<"The Authorization Server requires End-User interaction.">;
+        }, z.core.$strip>;
+    };
+    InvalidPasswordResetToken: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_PASSWORD_RESET_TOKEN";
+                readonly message: "The password reset token is invalid or has expired.";
+                toJson(): {
+                    code: "INVALID_PASSWORD_RESET_TOKEN";
+                    message: "The password reset token is invalid or has expired.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_PASSWORD_RESET_TOKEN">;
+            message: z.ZodLiteral<"The password reset token is invalid or has expired.">;
+        }, z.core.$strip>;
+    };
+    UserNotEditable: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "USER_NOT_EDITABLE";
+                readonly message: "This user account cannot be modified.";
+                toJson(): {
+                    code: "USER_NOT_EDITABLE";
+                    message: "This user account cannot be modified.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"USER_NOT_EDITABLE">;
+            message: z.ZodLiteral<"This user account cannot be modified.">;
+        }, z.core.$strip>;
+    };
+    OAuthProviderNotFound: {
+        Status: 404;
+        Error: {
+            new (): {
+                readonly status: 404;
+                readonly code: "OAUTH_PROVIDER_NOT_FOUND";
+                readonly message: "The OAuth provider is not configured or is disabled.";
+                toJson(): {
+                    code: "OAUTH_PROVIDER_NOT_FOUND";
+                    message: "The OAuth provider is not configured or is disabled.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_PROVIDER_NOT_FOUND">;
+            message: z.ZodLiteral<"The OAuth provider is not configured or is disabled.">;
+        }, z.core.$strip>;
+    };
+    OAuthStateMismatch: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "OAUTH_STATE_MISMATCH";
+                readonly message: "The OAuth state parameter does not match. Please try again.";
+                toJson(): {
+                    code: "OAUTH_STATE_MISMATCH";
+                    message: "The OAuth state parameter does not match. Please try again.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_STATE_MISMATCH">;
+            message: z.ZodLiteral<"The OAuth state parameter does not match. Please try again.">;
+        }, z.core.$strip>;
+    };
+    OAuthTokenExchangeFailed: {
+        Status: 502;
+        Error: {
+            new (): {
+                readonly status: 502;
+                readonly code: "OAUTH_TOKEN_EXCHANGE_FAILED";
+                readonly message: "Failed to exchange authorization code for tokens.";
+                toJson(): {
+                    code: "OAUTH_TOKEN_EXCHANGE_FAILED";
+                    message: "Failed to exchange authorization code for tokens.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_TOKEN_EXCHANGE_FAILED">;
+            message: z.ZodLiteral<"Failed to exchange authorization code for tokens.">;
+        }, z.core.$strip>;
+    };
+    OAuthUserInfoFailed: {
+        Status: 502;
+        Error: {
+            new (): {
+                readonly status: 502;
+                readonly code: "OAUTH_USERINFO_FAILED";
+                readonly message: "Failed to fetch user information from OAuth provider.";
+                toJson(): {
+                    code: "OAUTH_USERINFO_FAILED";
+                    message: "Failed to fetch user information from OAuth provider.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_USERINFO_FAILED">;
+            message: z.ZodLiteral<"Failed to fetch user information from OAuth provider.">;
+        }, z.core.$strip>;
+    };
+    OAuthAccountAlreadyLinked: {
+        Status: 409;
+        Error: {
+            new (): {
+                readonly status: 409;
+                readonly code: "OAUTH_ACCOUNT_ALREADY_LINKED";
+                readonly message: "This OAuth account is already linked to another user.";
+                toJson(): {
+                    code: "OAUTH_ACCOUNT_ALREADY_LINKED";
+                    message: "This OAuth account is already linked to another user.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_ACCOUNT_ALREADY_LINKED">;
+            message: z.ZodLiteral<"This OAuth account is already linked to another user.">;
+        }, z.core.$strip>;
+    };
+    OAuthAccountNotLinked: {
+        Status: 404;
+        Error: {
+            new (): {
+                readonly status: 404;
+                readonly code: "OAUTH_ACCOUNT_NOT_LINKED";
+                readonly message: "No OAuth account is linked for this provider.";
+                toJson(): {
+                    code: "OAUTH_ACCOUNT_NOT_LINKED";
+                    message: "No OAuth account is linked for this provider.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_ACCOUNT_NOT_LINKED">;
+            message: z.ZodLiteral<"No OAuth account is linked for this provider.">;
+        }, z.core.$strip>;
+    };
+    OAuthEmailNotVerified: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "OAUTH_EMAIL_NOT_VERIFIED";
+                readonly message: "The email address from the OAuth provider is not verified.";
+                toJson(): {
+                    code: "OAUTH_EMAIL_NOT_VERIFIED";
+                    message: "The email address from the OAuth provider is not verified.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_EMAIL_NOT_VERIFIED">;
+            message: z.ZodLiteral<"The email address from the OAuth provider is not verified.">;
+        }, z.core.$strip>;
+    };
+    OAuthEmailConflict: {
+        Status: 409;
+        Error: {
+            new (): {
+                readonly status: 409;
+                readonly code: "OAUTH_EMAIL_CONFLICT";
+                readonly message: "An account with this email already exists. Please link your account instead.";
+                toJson(): {
+                    code: "OAUTH_EMAIL_CONFLICT";
+                    message: "An account with this email already exists. Please link your account instead.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_EMAIL_CONFLICT">;
+            message: z.ZodLiteral<"An account with this email already exists. Please link your account instead.">;
+        }, z.core.$strip>;
+    };
+    CannotUnlinkLastAuthMethod: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "CANNOT_UNLINK_LAST_AUTH_METHOD";
+                readonly message: "Cannot unlink the last authentication method. You need at least one way to log in.";
+                toJson(): {
+                    code: "CANNOT_UNLINK_LAST_AUTH_METHOD";
+                    message: "Cannot unlink the last authentication method. You need at least one way to log in.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"CANNOT_UNLINK_LAST_AUTH_METHOD">;
+            message: z.ZodLiteral<"Cannot unlink the last authentication method. You need at least one way to log in.">;
+        }, z.core.$strip>;
+    };
+    OAuthSessionExpired: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "OAUTH_SESSION_EXPIRED";
+                readonly message: "The OAuth session has expired. Please start the login process again.";
+                toJson(): {
+                    code: "OAUTH_SESSION_EXPIRED";
+                    message: "The OAuth session has expired. Please start the login process again.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_SESSION_EXPIRED">;
+            message: z.ZodLiteral<"The OAuth session has expired. Please start the login process again.">;
+        }, z.core.$strip>;
+    };
+    OAuthInvalidRequest: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "OAUTH_INVALID_REQUEST";
+                readonly message: "Missing required parameters: code and state.";
+                toJson(): {
+                    code: "OAUTH_INVALID_REQUEST";
+                    message: "Missing required parameters: code and state.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"OAUTH_INVALID_REQUEST">;
+            message: z.ZodLiteral<"Missing required parameters: code and state.">;
+        }, z.core.$strip>;
+    };
+    Unauthorized: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "UNAUTHORIZED";
+                readonly message: "You must be logged in to perform this action.";
+                toJson(): {
+                    code: "UNAUTHORIZED";
+                    message: "You must be logged in to perform this action.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"UNAUTHORIZED">;
+            message: z.ZodLiteral<"You must be logged in to perform this action.">;
+        }, z.core.$strip>;
+    };
+    PasswordAlreadySet: {
+        Status: 409;
+        Error: {
+            new (): {
+                readonly status: 409;
+                readonly code: "PASSWORD_ALREADY_SET";
+                readonly message: "A password is already set for this account. Use password change instead.";
+                toJson(): {
+                    code: "PASSWORD_ALREADY_SET";
+                    message: "A password is already set for this account. Use password change instead.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"PASSWORD_ALREADY_SET">;
+            message: z.ZodLiteral<"A password is already set for this account. Use password change instead.">;
+        }, z.core.$strip>;
+    };
+    PasswordNotSet: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "PASSWORD_NOT_SET";
+                readonly message: "No password is set for this account.";
+                toJson(): {
+                    code: "PASSWORD_NOT_SET";
+                    message: "No password is set for this account.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"PASSWORD_NOT_SET">;
+            message: z.ZodLiteral<"No password is set for this account.">;
+        }, z.core.$strip>;
+    };
+    InvalidCurrentPassword: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "INVALID_CURRENT_PASSWORD";
+                readonly message: "The current password is incorrect.";
+                toJson(): {
+                    code: "INVALID_CURRENT_PASSWORD";
+                    message: "The current password is incorrect.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_CURRENT_PASSWORD">;
+            message: z.ZodLiteral<"The current password is incorrect.">;
+        }, z.core.$strip>;
+    };
+    CannotRemoveLastAuthMethod: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "CANNOT_REMOVE_LAST_AUTH_METHOD";
+                readonly message: "Cannot remove password. You need at least one way to log in.";
+                toJson(): {
+                    code: "CANNOT_REMOVE_LAST_AUTH_METHOD";
+                    message: "Cannot remove password. You need at least one way to log in.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"CANNOT_REMOVE_LAST_AUTH_METHOD">;
+            message: z.ZodLiteral<"Cannot remove password. You need at least one way to log in.">;
+        }, z.core.$strip>;
+    };
+    CannotRemovePasswordWithSecondFactorOnly: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "CANNOT_REMOVE_PASSWORD_WITH_SECOND_FACTOR_ONLY";
+                readonly message: "Cannot remove password when 2FA (TOTP/Passkey) is set up without OAuth. Add an OAuth account first, or disable 2FA before removing password.";
+                toJson(): {
+                    code: "CANNOT_REMOVE_PASSWORD_WITH_SECOND_FACTOR_ONLY";
+                    message: "Cannot remove password when 2FA (TOTP/Passkey) is set up without OAuth. Add an OAuth account first, or disable 2FA before removing password.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"CANNOT_REMOVE_PASSWORD_WITH_SECOND_FACTOR_ONLY">;
+            message: z.ZodLiteral<"Cannot remove password when 2FA (TOTP/Passkey) is set up without OAuth. Add an OAuth account first, or disable 2FA before removing password.">;
+        }, z.core.$strip>;
+    };
+    TotpAlreadyEnabled: {
+        Status: 409;
+        Error: {
+            new (): {
+                readonly status: 409;
+                readonly code: "TOTP_ALREADY_ENABLED";
+                readonly message: "TOTP is already enabled for this account.";
+                toJson(): {
+                    code: "TOTP_ALREADY_ENABLED";
+                    message: "TOTP is already enabled for this account.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"TOTP_ALREADY_ENABLED">;
+            message: z.ZodLiteral<"TOTP is already enabled for this account.">;
+        }, z.core.$strip>;
+    };
+    TotpNotEnabled: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "TOTP_NOT_ENABLED";
+                readonly message: "TOTP is not enabled for this account.";
+                toJson(): {
+                    code: "TOTP_NOT_ENABLED";
+                    message: "TOTP is not enabled for this account.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"TOTP_NOT_ENABLED">;
+            message: z.ZodLiteral<"TOTP is not enabled for this account.">;
+        }, z.core.$strip>;
+    };
+    TotpNotSetup: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "TOTP_NOT_SETUP";
+                readonly message: "TOTP setup has not been initiated. Please start setup first.";
+                toJson(): {
+                    code: "TOTP_NOT_SETUP";
+                    message: "TOTP setup has not been initiated. Please start setup first.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"TOTP_NOT_SETUP">;
+            message: z.ZodLiteral<"TOTP setup has not been initiated. Please start setup first.">;
+        }, z.core.$strip>;
+    };
+    InvalidTotpCode: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_TOTP_CODE";
+                readonly message: "The provided TOTP code is invalid.";
+                toJson(): {
+                    code: "INVALID_TOTP_CODE";
+                    message: "The provided TOTP code is invalid.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_TOTP_CODE">;
+            message: z.ZodLiteral<"The provided TOTP code is invalid.">;
+        }, z.core.$strip>;
+    };
+    TotpVerificationRequired: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "TOTP_VERIFICATION_REQUIRED";
+                readonly message: "TOTP verification is required to complete login.";
+                toJson(): {
+                    code: "TOTP_VERIFICATION_REQUIRED";
+                    message: "TOTP verification is required to complete login.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"TOTP_VERIFICATION_REQUIRED">;
+            message: z.ZodLiteral<"TOTP verification is required to complete login.">;
+        }, z.core.$strip>;
+    };
+    TotpVerificationSessionExpired: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "TOTP_VERIFICATION_SESSION_EXPIRED";
+                readonly message: "TOTP verification session has expired. Please login again.";
+                toJson(): {
+                    code: "TOTP_VERIFICATION_SESSION_EXPIRED";
+                    message: "TOTP verification session has expired. Please login again.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"TOTP_VERIFICATION_SESSION_EXPIRED">;
+            message: z.ZodLiteral<"TOTP verification session has expired. Please login again.">;
+        }, z.core.$strip>;
+    };
+    SecondFactorSessionExpired: {
+        Status: 401;
+        Error: {
+            new (): {
+                readonly status: 401;
+                readonly code: "SECOND_FACTOR_SESSION_EXPIRED";
+                readonly message: "Second factor authentication session has expired. Please login again.";
+                toJson(): {
+                    code: "SECOND_FACTOR_SESSION_EXPIRED";
+                    message: "Second factor authentication session has expired. Please login again.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"SECOND_FACTOR_SESSION_EXPIRED">;
+            message: z.ZodLiteral<"Second factor authentication session has expired. Please login again.">;
+        }, z.core.$strip>;
+    };
+    InvalidRecoveryCode: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "INVALID_RECOVERY_CODE";
+                readonly message: "The provided recovery code is invalid.";
+                toJson(): {
+                    code: "INVALID_RECOVERY_CODE";
+                    message: "The provided recovery code is invalid.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"INVALID_RECOVERY_CODE">;
+            message: z.ZodLiteral<"The provided recovery code is invalid.">;
+        }, z.core.$strip>;
+    };
+    NoRecoveryCodesAvailable: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "NO_RECOVERY_CODES_AVAILABLE";
+                readonly message: "No recovery codes are available. All codes have been used.";
+                toJson(): {
+                    code: "NO_RECOVERY_CODES_AVAILABLE";
+                    message: "No recovery codes are available. All codes have been used.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"NO_RECOVERY_CODES_AVAILABLE">;
+            message: z.ZodLiteral<"No recovery codes are available. All codes have been used.">;
+        }, z.core.$strip>;
+    };
+    PasskeyNotEnabled: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "PASSKEY_NOT_ENABLED";
+                readonly message: "Passkey authentication is not enabled.";
+                toJson(): {
+                    code: "PASSKEY_NOT_ENABLED";
+                    message: "Passkey authentication is not enabled.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"PASSKEY_NOT_ENABLED">;
+            message: z.ZodLiteral<"Passkey authentication is not enabled.">;
+        }, z.core.$strip>;
+    };
+    PasskeyNotFound: {
+        Status: 404;
+        Error: {
+            new (): {
+                readonly status: 404;
+                readonly code: "PASSKEY_NOT_FOUND";
+                readonly message: "The passkey was not found.";
+                toJson(): {
+                    code: "PASSKEY_NOT_FOUND";
+                    message: "The passkey was not found.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"PASSKEY_NOT_FOUND">;
+            message: z.ZodLiteral<"The passkey was not found.">;
+        }, z.core.$strip>;
+    };
+    PasskeyAlreadyExists: {
+        Status: 409;
+        Error: {
+            new (): {
+                readonly status: 409;
+                readonly code: "PASSKEY_ALREADY_EXISTS";
+                readonly message: "This passkey is already registered.";
+                toJson(): {
+                    code: "PASSKEY_ALREADY_EXISTS";
+                    message: "This passkey is already registered.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"PASSKEY_ALREADY_EXISTS">;
+            message: z.ZodLiteral<"This passkey is already registered.">;
+        }, z.core.$strip>;
+    };
+    PasskeyVerificationFailed: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "PASSKEY_VERIFICATION_FAILED";
+                readonly message: "Passkey verification failed.";
+                toJson(): {
+                    code: "PASSKEY_VERIFICATION_FAILED";
+                    message: "Passkey verification failed.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"PASSKEY_VERIFICATION_FAILED">;
+            message: z.ZodLiteral<"Passkey verification failed.">;
+        }, z.core.$strip>;
+    };
+    PasskeyChallengeExpired: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "PASSKEY_CHALLENGE_EXPIRED";
+                readonly message: "The passkey challenge has expired. Please try again.";
+                toJson(): {
+                    code: "PASSKEY_CHALLENGE_EXPIRED";
+                    message: "The passkey challenge has expired. Please try again.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"PASSKEY_CHALLENGE_EXPIRED">;
+            message: z.ZodLiteral<"The passkey challenge has expired. Please try again.">;
+        }, z.core.$strip>;
+    };
+    PasskeyChallengeNotFound: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "PASSKEY_CHALLENGE_NOT_FOUND";
+                readonly message: "No passkey challenge found. Please start the registration process again.";
+                toJson(): {
+                    code: "PASSKEY_CHALLENGE_NOT_FOUND";
+                    message: "No passkey challenge found. Please start the registration process again.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"PASSKEY_CHALLENGE_NOT_FOUND">;
+            message: z.ZodLiteral<"No passkey challenge found. Please start the registration process again.">;
+        }, z.core.$strip>;
+    };
+    CannotRemoveLastPasskey: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "CANNOT_REMOVE_LAST_PASSKEY";
+                readonly message: "Cannot remove the last passkey. You need at least one way to log in.";
+                toJson(): {
+                    code: "CANNOT_REMOVE_LAST_PASSKEY";
+                    message: "Cannot remove the last passkey. You need at least one way to log in.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"CANNOT_REMOVE_LAST_PASSKEY">;
+            message: z.ZodLiteral<"Cannot remove the last passkey. You need at least one way to log in.">;
+        }, z.core.$strip>;
+    };
+    CannotRemoveLastSecondFactor: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "CANNOT_REMOVE_LAST_SECOND_FACTOR";
+                readonly message: "Cannot remove the last second factor. At least one 2FA method is required.";
+                toJson(): {
+                    code: "CANNOT_REMOVE_LAST_SECOND_FACTOR";
+                    message: "Cannot remove the last second factor. At least one 2FA method is required.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"CANNOT_REMOVE_LAST_SECOND_FACTOR">;
+            message: z.ZodLiteral<"Cannot remove the last second factor. At least one 2FA method is required.">;
+        }, z.core.$strip>;
+    };
+    SecondFactorNotAllowedForConfigUser: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "SECOND_FACTOR_NOT_ALLOWED_FOR_CONFIG_USER";
+                readonly message: "Second factor authentication is not available for config-managed users.";
+                toJson(): {
+                    code: "SECOND_FACTOR_NOT_ALLOWED_FOR_CONFIG_USER";
+                    message: "Second factor authentication is not available for config-managed users.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"SECOND_FACTOR_NOT_ALLOWED_FOR_CONFIG_USER">;
+            message: z.ZodLiteral<"Second factor authentication is not available for config-managed users.">;
+        }, z.core.$strip>;
+    };
+    PasskeyUserMismatch: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "PASSKEY_USER_MISMATCH";
+                readonly message: "The passkey does not belong to the pending user.";
+                toJson(): {
+                    code: "PASSKEY_USER_MISMATCH";
+                    message: "The passkey does not belong to the pending user.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"PASSKEY_USER_MISMATCH">;
+            message: z.ZodLiteral<"The passkey does not belong to the pending user.">;
+        }, z.core.$strip>;
+    };
+    EmailVerificationRequired: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "EMAIL_VERIFICATION_REQUIRED";
+                readonly message: "Email verification is required before logging in.";
+                toJson(): {
+                    code: "EMAIL_VERIFICATION_REQUIRED";
+                    message: "Email verification is required before logging in.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"EMAIL_VERIFICATION_REQUIRED">;
+            message: z.ZodLiteral<"Email verification is required before logging in.">;
+        }, z.core.$strip>;
+    };
+    AccountDeletionDisabled: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "ACCOUNT_DELETION_DISABLED";
+                readonly message: "Account deletion is not enabled.";
+                toJson(): {
+                    code: "ACCOUNT_DELETION_DISABLED";
+                    message: "Account deletion is not enabled.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"ACCOUNT_DELETION_DISABLED">;
+            message: z.ZodLiteral<"Account deletion is not enabled.">;
+        }, z.core.$strip>;
+    };
+    AccountAlreadyDeleted: {
+        Status: 400;
+        Error: {
+            new (): {
+                readonly status: 400;
+                readonly code: "ACCOUNT_ALREADY_DELETED";
+                readonly message: "This account has already been deleted.";
+                toJson(): {
+                    code: "ACCOUNT_ALREADY_DELETED";
+                    message: "This account has already been deleted.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"ACCOUNT_ALREADY_DELETED">;
+            message: z.ZodLiteral<"This account has already been deleted.">;
+        }, z.core.$strip>;
+    };
+    TermsConsentRequired: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "TERMS_CONSENT_REQUIRED";
+                readonly message: "You must agree to the terms of service before continuing.";
+                toJson(): {
+                    code: "TERMS_CONSENT_REQUIRED";
+                    message: "You must agree to the terms of service before continuing.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"TERMS_CONSENT_REQUIRED">;
+            message: z.ZodLiteral<"You must agree to the terms of service before continuing.">;
+        }, z.core.$strip>;
+    };
+    TermsNotFound: {
+        Status: 404;
+        Error: {
+            new (): {
+                readonly status: 404;
+                readonly code: "TERMS_NOT_FOUND";
+                readonly message: "The specified terms were not found.";
+                toJson(): {
+                    code: "TERMS_NOT_FOUND";
+                    message: "The specified terms were not found.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"TERMS_NOT_FOUND">;
+            message: z.ZodLiteral<"The specified terms were not found.">;
+        }, z.core.$strip>;
+    };
+    UntrustedProxy: {
+        Status: 403;
+        Error: {
+            new (): {
+                readonly status: 403;
+                readonly code: "UNTRUSTED_PROXY";
+                readonly message: "Request rejected: connection from untrusted source.";
+                toJson(): {
+                    code: "UNTRUSTED_PROXY";
+                    message: "Request rejected: connection from untrusted source.";
+                };
+                name: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        Schema: z.ZodObject<{
+            code: z.ZodLiteral<"UNTRUSTED_PROXY">;
+            message: z.ZodLiteral<"Request rejected: connection from untrusted source.">;
+        }, z.core.$strip>;
+    };
+};
+//# sourceMappingURL=error.d.ts.map