@gatwech/auth 1.0.0-beta.18

package/dist/client-BOX93C3d.d.mts

@@ -0,0 +1,1250 @@
+import { o as LiteralString } from "./helper-tmxW3BHj.mjs";
+import { g as User } from "./index-Cxi7TbLE.mjs";
+import { t as InferOptionSchema } from "./plugins-hFZT3hmK.mjs";
+import * as _gatwech_core14 from "@gatwech/core";
+import { PayvoAuthPlugin } from "@gatwech/core";
+import * as better_call41 from "better-call";
+import * as z$1 from "zod";
+import * as _better_fetch_fetch16 from "@better-fetch/fetch";
+
+//#region src/plugins/two-factor/backup-codes/index.d.ts
+interface BackupCodeOptions {
+  /**
+   * The amount of backup codes to generate
+   *
+   * @default 10
+   */
+  amount?: number | undefined;
+  /**
+   * The length of the backup codes
+   *
+   * @default 10
+   */
+  length?: number | undefined;
+  /**
+   * An optional custom function to generate backup codes
+   */
+  customBackupCodesGenerate?: (() => string[]) | undefined;
+  /**
+   * How to store the backup codes in the database, whether encrypted or plain.
+   */
+  storeBackupCodes?: ("plain" | "encrypted" | {
+    encrypt: (token: string) => Promise<string>;
+    decrypt: (token: string) => Promise<string>;
+  }) | undefined;
+}
+//#endregion
+//#region src/plugins/two-factor/otp/index.d.ts
+interface OTPOptions {
+  /**
+   * How long the opt will be valid for in
+   * minutes
+   *
+   * @default "3 mins"
+   */
+  period?: number | undefined;
+  /**
+   * Number of digits for the OTP code
+   *
+   * @default 6
+   */
+  digits?: number | undefined;
+  /**
+   * Send the otp to the user
+   *
+   * @param user - The user to send the otp to
+   * @param otp - The otp to send
+   * @param request - The request object
+   * @returns void | Promise<void>
+   */
+  sendOTP?: ((
+  /**
+   * The user to send the otp to
+   * @type UserWithTwoFactor
+   * @default UserWithTwoFactors
+   */
+  data: {
+    user: UserWithTwoFactor;
+    otp: string;
+  },
+  /**
+   * The request object
+   */
+  request?: Request) => Promise<void> | void) | undefined;
+  /**
+   * The number of allowed attempts for the OTP
+   *
+   * @default 5
+   */
+  allowedAttempts?: number | undefined;
+  storeOTP?: ("plain" | "encrypted" | "hashed" | {
+    hash: (token: string) => Promise<string>;
+  } | {
+    encrypt: (token: string) => Promise<string>;
+    decrypt: (token: string) => Promise<string>;
+  }) | undefined;
+}
+//#endregion
+//#region src/plugins/two-factor/schema.d.ts
+declare const schema: {
+  user: {
+    fields: {
+      twoFactorEnabled: {
+        type: "boolean";
+        required: false;
+        defaultValue: false;
+        input: false;
+      };
+    };
+  };
+  twoFactor: {
+    fields: {
+      secret: {
+        type: "string";
+        required: true;
+        returned: false;
+      };
+      backupCodes: {
+        type: "string";
+        required: true;
+        returned: false;
+      };
+      userId: {
+        type: "string";
+        required: true;
+        returned: false;
+        references: {
+          model: string;
+          field: string;
+        };
+      };
+    };
+  };
+};
+//#endregion
+//#region src/plugins/two-factor/totp/index.d.ts
+type TOTPOptions = {
+  /**
+   * Issuer
+   */
+  issuer?: string | undefined;
+  /**
+   * How many digits the otp to be
+   *
+   * @default 6
+   */
+  digits?: (6 | 8) | undefined;
+  /**
+   * Period for otp in seconds.
+   * @default 30
+   */
+  period?: number | undefined;
+  /**
+   * Backup codes configuration
+   */
+  backupCodes?: BackupCodeOptions | undefined;
+  /**
+   * Disable totp
+   */
+  disable?: boolean | undefined;
+};
+//#endregion
+//#region src/plugins/two-factor/types.d.ts
+interface TwoFactorOptions {
+  /**
+   * Application Name
+   */
+  issuer?: string | undefined;
+  /**
+   * TOTP OPtions
+   */
+  totpOptions?: Omit<TOTPOptions, "issuer"> | undefined;
+  /**
+   * OTP Options
+   */
+  otpOptions?: OTPOptions | undefined;
+  /**
+   * Backup code options
+   */
+  backupCodeOptions?: BackupCodeOptions | undefined;
+  /**
+   * Skip verification on enabling two factor authentication.
+   * @default false
+   */
+  skipVerificationOnEnable?: boolean | undefined;
+  /**
+   * Custom schema for the two factor plugin
+   */
+  schema?: InferOptionSchema<typeof schema> | undefined;
+}
+interface UserWithTwoFactor extends User {
+  /**
+   * If the user has enabled two factor authentication.
+   */
+  twoFactorEnabled: boolean;
+}
+interface TwoFactorProvider {
+  id: LiteralString;
+  endpoints?: PayvoAuthPlugin["endpoints"] | undefined;
+}
+interface TwoFactorTable {
+  userId: string;
+  secret: string;
+  backupCodes: string;
+  enabled: boolean;
+}
+//#endregion
+//#region src/plugins/two-factor/error-code.d.ts
+declare const TWO_FACTOR_ERROR_CODES: {
+  readonly OTP_NOT_ENABLED: "OTP not enabled";
+  readonly OTP_HAS_EXPIRED: "OTP has expired";
+  readonly TOTP_NOT_ENABLED: "TOTP not enabled";
+  readonly TWO_FACTOR_NOT_ENABLED: "Two factor isn't enabled";
+  readonly BACKUP_CODES_NOT_ENABLED: "Backup codes aren't enabled";
+  readonly INVALID_BACKUP_CODE: "Invalid backup code";
+  readonly INVALID_CODE: "Invalid code";
+  readonly TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: "Too many attempts. Please request a new code.";
+  readonly INVALID_TWO_FACTOR_COOKIE: "Invalid two factor cookie";
+};
+//#endregion
+//#region src/plugins/two-factor/index.d.ts
+declare const twoFactor: (options?: TwoFactorOptions | undefined) => {
+  id: "two-factor";
+  endpoints: {
+    /**
+     * ### Endpoint
+     *
+     * POST `/two-factor/enable`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.enableTwoFactor`
+     *
+     * **client:**
+     * `authClient.twoFactor.enable`
+     *
+     * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/2fa#api-method-two-factor-enable)
+     */
+    enableTwoFactor: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          password: string;
+          issuer?: string | undefined;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          totpURI: string;
+          backupCodes: string[];
+        };
+      } : {
+        totpURI: string;
+        backupCodes: string[];
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          password: z$1.ZodString;
+          issuer: z$1.ZodOptional<z$1.ZodString>;
+        }, z$1.core.$strip>;
+        use: ((inputContext: better_call41.MiddlewareInputContext<better_call41.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        totpURI: {
+                          type: string;
+                          description: string;
+                        };
+                        backupCodes: {
+                          type: string;
+                          items: {
+                            type: string;
+                          };
+                          description: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/two-factor/enable";
+    };
+    /**
+     * ### Endpoint
+     *
+     * POST `/two-factor/disable`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.disableTwoFactor`
+     *
+     * **client:**
+     * `authClient.twoFactor.disable`
+     *
+     * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/2fa#api-method-two-factor-disable)
+     */
+    disableTwoFactor: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          password: string;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          status: boolean;
+        };
+      } : {
+        status: boolean;
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          password: z$1.ZodString;
+        }, z$1.core.$strip>;
+        use: ((inputContext: better_call41.MiddlewareInputContext<better_call41.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/two-factor/disable";
+    };
+    verifyBackupCode: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          code: string;
+          disableSession?: boolean | undefined;
+          trustDevice?: boolean | undefined;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          token: string | undefined;
+          user: {
+            id: string;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image: string | null | undefined;
+            createdAt: Date;
+            updatedAt: Date;
+          };
+        };
+      } : {
+        token: string | undefined;
+        user: {
+          id: string;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image: string | null | undefined;
+          createdAt: Date;
+          updatedAt: Date;
+        };
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          code: z$1.ZodString;
+          disableSession: z$1.ZodOptional<z$1.ZodBoolean>;
+          trustDevice: z$1.ZodOptional<z$1.ZodBoolean>;
+        }, z$1.core.$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user: {
+                          type: string;
+                          properties: {
+                            id: {
+                              type: string;
+                              description: string;
+                            };
+                            email: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            emailVerified: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            name: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            image: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            twoFactorEnabled: {
+                              type: string;
+                              description: string;
+                            };
+                            createdAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                            updatedAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                          description: string;
+                        };
+                        session: {
+                          type: string;
+                          properties: {
+                            token: {
+                              type: string;
+                              description: string;
+                            };
+                            userId: {
+                              type: string;
+                              description: string;
+                            };
+                            createdAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                            expiresAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/two-factor/verify-backup-code";
+    };
+    generateBackupCodes: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          password: string;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          status: boolean;
+          backupCodes: string[];
+        };
+      } : {
+        status: boolean;
+        backupCodes: string[];
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          password: z$1.ZodString;
+        }, z$1.core.$strip>;
+        use: ((inputContext: better_call41.MiddlewareInputContext<better_call41.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>)[];
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                          description: string;
+                          enum: boolean[];
+                        };
+                        backupCodes: {
+                          type: string;
+                          items: {
+                            type: string;
+                          };
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/two-factor/generate-backup-codes";
+    };
+    viewBackupCodes: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          userId: unknown;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          status: boolean;
+          backupCodes: string[];
+        };
+      } : {
+        status: boolean;
+        backupCodes: string[];
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          userId: z$1.ZodCoercedString<unknown>;
+        }, z$1.core.$strip>;
+        metadata: {
+          SERVER_ONLY: true;
+        };
+      } & {
+        use: any[];
+      };
+      path: "/two-factor/view-backup-codes";
+    };
+    sendTwoFactorOTP: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+        body?: {
+          trustDevice?: boolean | undefined;
+        } | undefined;
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          status: boolean;
+        };
+      } : {
+        status: boolean;
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodOptional<z$1.ZodObject<{
+          trustDevice: z$1.ZodOptional<z$1.ZodBoolean>;
+        }, z$1.core.$strip>>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/two-factor/send-otp";
+    };
+    verifyTwoFactorOTP: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          code: string;
+          trustDevice?: boolean | undefined;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          token: string;
+          user: {
+            id: any;
+            email: any;
+            emailVerified: any;
+            name: any;
+            image: any;
+            createdAt: any;
+            updatedAt: any;
+          };
+        };
+      } : {
+        token: string;
+        user: {
+          id: any;
+          email: any;
+          emailVerified: any;
+          name: any;
+          image: any;
+          createdAt: any;
+          updatedAt: any;
+        };
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          code: z$1.ZodString;
+          trustDevice: z$1.ZodOptional<z$1.ZodBoolean>;
+        }, z$1.core.$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              "200": {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        token: {
+                          type: string;
+                          description: string;
+                        };
+                        user: {
+                          type: string;
+                          properties: {
+                            id: {
+                              type: string;
+                              description: string;
+                            };
+                            email: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            emailVerified: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            name: {
+                              type: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            image: {
+                              type: string;
+                              format: string;
+                              nullable: boolean;
+                              description: string;
+                            };
+                            createdAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                            updatedAt: {
+                              type: string;
+                              format: string;
+                              description: string;
+                            };
+                          };
+                          required: string[];
+                          description: string;
+                        };
+                      };
+                      required: string[];
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/two-factor/verify-otp";
+    };
+    generateTOTP: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          secret: string;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          code: string;
+        };
+      } : {
+        code: string;
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          secret: z$1.ZodString;
+        }, z$1.core.$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        code: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+          SERVER_ONLY: true;
+        };
+      } & {
+        use: any[];
+      };
+      path: "/totp/generate";
+    };
+    getTOTPURI: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          password: string;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          totpURI: string;
+        };
+      } : {
+        totpURI: string;
+      }>;
+      options: {
+        method: "POST";
+        use: ((inputContext: better_call41.MiddlewareInputContext<better_call41.MiddlewareOptions>) => Promise<{
+          session: {
+            session: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              userId: string;
+              expiresAt: Date;
+              token: string;
+              ipAddress?: string | null | undefined;
+              userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name: string;
+              image?: string | null | undefined;
+            };
+          };
+        }>)[];
+        body: z$1.ZodObject<{
+          password: z$1.ZodString;
+        }, z$1.core.$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        totpURI: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/two-factor/get-totp-uri";
+    };
+    verifyTOTP: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          code: string;
+          trustDevice?: boolean | undefined;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call41.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          token: string;
+          user: {
+            id: string;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image: string | null | undefined;
+            createdAt: Date;
+            updatedAt: Date;
+          };
+        };
+      } : {
+        token: string;
+        user: {
+          id: string;
+          email: string;
+          emailVerified: boolean;
+          name: string;
+          image: string | null | undefined;
+          createdAt: Date;
+          updatedAt: Date;
+        };
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          code: z$1.ZodString;
+          trustDevice: z$1.ZodOptional<z$1.ZodBoolean>;
+        }, z$1.core.$strip>;
+        metadata: {
+          openapi: {
+            summary: string;
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        status: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/two-factor/verify-totp";
+    };
+  };
+  options: TwoFactorOptions | undefined;
+  hooks: {
+    after: {
+      matcher(context: _gatwech_core14.HookEndpointContext): boolean;
+      handler: (inputContext: better_call41.MiddlewareInputContext<better_call41.MiddlewareOptions>) => Promise<{
+        twoFactorRedirect: boolean;
+      } | undefined>;
+    }[];
+  };
+  schema: {
+    user: {
+      fields: {
+        twoFactorEnabled: {
+          type: "boolean";
+          required: false;
+          defaultValue: false;
+          input: false;
+        };
+      };
+    };
+    twoFactor: {
+      fields: {
+        secret: {
+          type: "string";
+          required: true;
+          returned: false;
+        };
+        backupCodes: {
+          type: "string";
+          required: true;
+          returned: false;
+        };
+        userId: {
+          type: "string";
+          required: true;
+          returned: false;
+          references: {
+            model: string;
+            field: string;
+          };
+        };
+      };
+    };
+  };
+  rateLimit: {
+    pathMatcher(path: string): boolean;
+    window: number;
+    max: number;
+  }[];
+  $ERROR_CODES: {
+    readonly OTP_NOT_ENABLED: "OTP not enabled";
+    readonly OTP_HAS_EXPIRED: "OTP has expired";
+    readonly TOTP_NOT_ENABLED: "TOTP not enabled";
+    readonly TWO_FACTOR_NOT_ENABLED: "Two factor isn't enabled";
+    readonly BACKUP_CODES_NOT_ENABLED: "Backup codes aren't enabled";
+    readonly INVALID_BACKUP_CODE: "Invalid backup code";
+    readonly INVALID_CODE: "Invalid code";
+    readonly TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: "Too many attempts. Please request a new code.";
+    readonly INVALID_TWO_FACTOR_COOKIE: "Invalid two factor cookie";
+  };
+};
+//#endregion
+//#region src/plugins/two-factor/client.d.ts
+declare const twoFactorClient: (options?: {
+  /**
+   * a redirect function to call if a user needs to verify
+   * their two factor
+   */
+  onTwoFactorRedirect?: () => void | Promise<void>;
+} | undefined) => {
+  id: "two-factor";
+  $InferServerPlugin: ReturnType<typeof twoFactor>;
+  atomListeners: {
+    matcher: (path: string) => boolean;
+    signal: "$sessionSignal";
+  }[];
+  pathMethods: {
+    "/two-factor/disable": "POST";
+    "/two-factor/enable": "POST";
+    "/two-factor/send-otp": "POST";
+    "/two-factor/generate-backup-codes": "POST";
+  };
+  fetchPlugins: {
+    id: string;
+    name: string;
+    hooks: {
+      onSuccess(context: _better_fetch_fetch16.SuccessContext<any>): Promise<void>;
+    };
+  }[];
+};
+//#endregion
+export { TwoFactorProvider as a, TwoFactorOptions as i, twoFactor as n, TwoFactorTable as o, TWO_FACTOR_ERROR_CODES as r, UserWithTwoFactor as s, twoFactorClient as t };