@porulle/core 0.10.8 → 0.13.0

package/dist/auth/auth-schema-guard.d.ts

@@ -0,0 +1,2444 @@
+/**
+ * Compares Porulle's Drizzle auth tables against better-auth's canonical
+ * {@link getAuthTables} output so a dependency minor bump cannot add a column
+ * the declared schema omits.
+ */
+import type { BetterAuthOptions } from "better-auth";
+/**
+ * Every plugin {@link createAuth} can enable, not only the ones it enables by
+ * default. The shipped schema has to satisfy any configuration a merchant
+ * chooses, so the guard compares against the maximal table set: a column that
+ * only `twoFactor` needs is still a column this package must declare.
+ */
+export declare const AUTH_SCHEMA_GUARD_OPTIONS: {
+    plugins: [import("better-auth/plugins").DefaultOrganizationPlugin<{
+        roles: {};
+    }>, {
+        id: "bearer";
+        version: string;
+        hooks: {
+            before: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    context: {
+                        headers: Headers;
+                    };
+                } | undefined>>;
+            }[];
+            after: {
+                matcher(context: import("better-auth").HookEndpointContext): true;
+                handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>;
+            }[];
+        };
+        options: import("better-auth/plugins").BearerOptions | undefined;
+    }, {
+        id: "jwt";
+        version: string;
+        options: NoInfer<import("better-auth/plugins").JwtOptions>;
+        init(ctx: import("better-auth").AuthContext): {
+            context: {
+                sessionConfig: {
+                    cookieCacheSigner: import("better-auth").CookieCacheSigner;
+                    updateAge: number;
+                    expiresIn: number;
+                    freshAge: number;
+                    cookieRefreshCache: false | {
+                        enabled: true;
+                        updateAge: number;
+                    };
+                };
+            };
+        } | undefined;
+        endpoints: {
+            getJwks: import("better-auth").StrictEndpoint<string, {
+                method: "GET";
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                keys: {
+                                                    type: string;
+                                                    description: string;
+                                                    items: {
+                                                        type: string;
+                                                        properties: {
+                                                            kid: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            kty: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            alg: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            use: {
+                                                                type: string;
+                                                                description: string;
+                                                                enum: string[];
+                                                                nullable: boolean;
+                                                            };
+                                                            n: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            e: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            crv: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            x: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            y: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("better-auth").JSONWebKeySet>;
+            getToken: import("better-auth").StrictEndpoint<"/token", {
+                method: "GET";
+                requireHeaders: true;
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").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: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+            }>;
+            signJWT: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                metadata: {
+                    $Infer: {
+                        body: {
+                            payload: import("better-auth").JWTPayload;
+                            overrideOptions?: import("better-auth/plugins").JwtOptions | undefined;
+                        };
+                    };
+                };
+                body: import("better-auth").ZodObject<{
+                    payload: import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodAny>;
+                    overrideOptions: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodAny>>;
+                }, import("zod/v4/core").$strip>;
+            }, {
+                token: string;
+            }>;
+            verifyJWT: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                metadata: {
+                    $Infer: {
+                        body: {
+                            token: string;
+                            issuer?: string;
+                        };
+                        response: {
+                            payload: {
+                                sub: string;
+                                aud: string;
+                                [key: string]: any;
+                            } | null;
+                        };
+                    };
+                };
+                body: import("better-auth").ZodObject<{
+                    token: import("better-auth").ZodString;
+                    issuer: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+            }, {
+                payload: (import("better-auth").JWTPayload & Required<Pick<import("better-auth").JWTPayload, "sub" | "aud">>) | null;
+            }>;
+        };
+        hooks: {
+            after: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>;
+            }[];
+        };
+        schema: {
+            jwks: {
+                fields: {
+                    publicKey: {
+                        type: "string";
+                        required: true;
+                    };
+                    privateKey: {
+                        type: "string";
+                        required: true;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                    };
+                    expiresAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    alg: {
+                        type: "string";
+                        required: false;
+                    };
+                    crv: {
+                        type: "string";
+                        required: false;
+                    };
+                };
+            };
+        };
+    }, {
+        id: "two-factor";
+        version: string;
+        endpoints: {
+            enableTwoFactor: import("better-auth").StrictEndpoint<"/two-factor/enable", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    password: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    method: import("better-auth").ZodDefault<import("better-auth").ZodEnum<{
+                        otp: "otp";
+                        totp: "totp";
+                    }>>;
+                    issuer: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip> | import("better-auth").ZodObject<{
+                    password: import("better-auth").ZodString;
+                    method: import("better-auth").ZodDefault<import("better-auth").ZodEnum<{
+                        otp: "otp";
+                        totp: "totp";
+                    }>>;
+                    issuer: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").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: {
+                                                method: {
+                                                    type: string;
+                                                    enum: string[];
+                                                    description: string;
+                                                };
+                                                totpURI: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                backupCodes: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                method: "otp";
+            } | {
+                method: "totp";
+                totpURI: string;
+                backupCodes: string[];
+            }>;
+            disableTwoFactor: import("better-auth").StrictEndpoint<"/two-factor/disable", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    password: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip> | import("better-auth").ZodObject<{
+                    password: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").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;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            verifyBackupCode: import("better-auth").StrictEndpoint<"/two-factor/verify-backup-code", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    code: import("better-auth").ZodString;
+                    disableSession: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    trustDevice: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                }, import("zod/v4/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[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string | undefined;
+                user: (Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                }) | import("better-auth/plugins").UserWithTwoFactor;
+            }>;
+            generateBackupCodes: import("better-auth").StrictEndpoint<"/two-factor/generate-backup-codes", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    password: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip> | import("better-auth").ZodObject<{
+                    password: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").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[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+                backupCodes: string[];
+            }>;
+            viewBackupCodes: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    userId: import("better-auth").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+            }, {
+                status: boolean;
+                backupCodes: string[];
+            }>;
+            sendTwoFactorOTP: import("better-auth").StrictEndpoint<"/two-factor/send-otp", {
+                method: "POST";
+                body: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
+                    trustDevice: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            verifyTwoFactorOTP: import("better-auth").StrictEndpoint<"/two-factor/verify-otp", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    code: import("better-auth").ZodString;
+                    trustDevice: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                }, import("zod/v4/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[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: import("better-auth/plugins").UserWithTwoFactor;
+            } | {
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }>;
+            generateTOTP: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    secret: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                code: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                code: string;
+            }>;
+            getTOTPURI: import("better-auth").StrictEndpoint<"/two-factor/get-totp-uri", {
+                method: "POST";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").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: import("better-auth").ZodObject<{
+                    password: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip> | import("better-auth").ZodObject<{
+                    password: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                totpURI: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                totpURI: string;
+            }>;
+            verifyTOTP: import("better-auth").StrictEndpoint<"/two-factor/verify-totp", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    code: import("better-auth").ZodString;
+                    trustDevice: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: import("better-auth/plugins").UserWithTwoFactor;
+            } | {
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }>;
+        };
+        options: NoInfer<{
+            issuer: string;
+        }>;
+        hooks: {
+            after: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    twoFactorRedirect: boolean;
+                    twoFactorMethods: string[];
+                } | undefined>>;
+            }[];
+        };
+        schema: {
+            user: {
+                fields: {
+                    twoFactorEnabled: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: false;
+                        input: false;
+                    };
+                };
+            };
+            twoFactor: {
+                fields: {
+                    secret: {
+                        type: "string";
+                        required: true;
+                        returned: false;
+                        index: true;
+                    };
+                    backupCodes: {
+                        type: "string";
+                        required: true;
+                        returned: false;
+                    };
+                    userId: {
+                        type: "string";
+                        required: true;
+                        returned: false;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    verified: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: true;
+                        input: false;
+                    };
+                    failedVerificationCount: {
+                        type: "number";
+                        required: false;
+                        defaultValue: number;
+                        input: false;
+                        returned: false;
+                    };
+                    lockedUntil: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                        returned: false;
+                    };
+                };
+            };
+        };
+        rateLimit: {
+            pathMatcher(path: string): boolean;
+            window: number;
+            max: number;
+        }[];
+        $ERROR_CODES: {
+            OTP_NOT_ENABLED: import("better-auth").RawError<"OTP_NOT_ENABLED">;
+            OTP_NOT_CONFIGURED: import("better-auth").RawError<"OTP_NOT_CONFIGURED">;
+            OTP_HAS_EXPIRED: import("better-auth").RawError<"OTP_HAS_EXPIRED">;
+            TOTP_NOT_ENABLED: import("better-auth").RawError<"TOTP_NOT_ENABLED">;
+            TOTP_NOT_CONFIGURED: import("better-auth").RawError<"TOTP_NOT_CONFIGURED">;
+            TWO_FACTOR_NOT_ENABLED: import("better-auth").RawError<"TWO_FACTOR_NOT_ENABLED">;
+            BACKUP_CODES_NOT_ENABLED: import("better-auth").RawError<"BACKUP_CODES_NOT_ENABLED">;
+            INVALID_BACKUP_CODE: import("better-auth").RawError<"INVALID_BACKUP_CODE">;
+            INVALID_CODE: import("better-auth").RawError<"INVALID_CODE">;
+            TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+            ACCOUNT_TEMPORARILY_LOCKED: import("better-auth").RawError<"ACCOUNT_TEMPORARILY_LOCKED">;
+            INVALID_TWO_FACTOR_COOKIE: import("better-auth").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+        };
+    }, {
+        id: "api-key";
+        version: string;
+        $ERROR_CODES: {
+            INVALID_METADATA_TYPE: import("better-auth").RawError<"INVALID_METADATA_TYPE">;
+            REFILL_AMOUNT_AND_INTERVAL_REQUIRED: import("better-auth").RawError<"REFILL_AMOUNT_AND_INTERVAL_REQUIRED">;
+            REFILL_INTERVAL_AND_AMOUNT_REQUIRED: import("better-auth").RawError<"REFILL_INTERVAL_AND_AMOUNT_REQUIRED">;
+            USER_BANNED: import("better-auth").RawError<"USER_BANNED">;
+            UNAUTHORIZED_SESSION: import("better-auth").RawError<"UNAUTHORIZED_SESSION">;
+            KEY_NOT_FOUND: import("better-auth").RawError<"KEY_NOT_FOUND">;
+            KEY_DISABLED: import("better-auth").RawError<"KEY_DISABLED">;
+            KEY_EXPIRED: import("better-auth").RawError<"KEY_EXPIRED">;
+            USAGE_EXCEEDED: import("better-auth").RawError<"USAGE_EXCEEDED">;
+            KEY_NOT_RECOVERABLE: import("better-auth").RawError<"KEY_NOT_RECOVERABLE">;
+            EXPIRES_IN_IS_TOO_SMALL: import("better-auth").RawError<"EXPIRES_IN_IS_TOO_SMALL">;
+            EXPIRES_IN_IS_TOO_LARGE: import("better-auth").RawError<"EXPIRES_IN_IS_TOO_LARGE">;
+            INVALID_REMAINING: import("better-auth").RawError<"INVALID_REMAINING">;
+            INVALID_PREFIX_LENGTH: import("better-auth").RawError<"INVALID_PREFIX_LENGTH">;
+            INVALID_NAME_LENGTH: import("better-auth").RawError<"INVALID_NAME_LENGTH">;
+            METADATA_DISABLED: import("better-auth").RawError<"METADATA_DISABLED">;
+            RATE_LIMIT_EXCEEDED: import("better-auth").RawError<"RATE_LIMIT_EXCEEDED">;
+            NO_VALUES_TO_UPDATE: import("better-auth").RawError<"NO_VALUES_TO_UPDATE">;
+            KEY_DISABLED_EXPIRATION: import("better-auth").RawError<"KEY_DISABLED_EXPIRATION">;
+            INVALID_API_KEY: import("better-auth").RawError<"INVALID_API_KEY">;
+            INVALID_USER_ID_FROM_API_KEY: import("better-auth").RawError<"INVALID_USER_ID_FROM_API_KEY">;
+            INVALID_REFERENCE_ID_FROM_API_KEY: import("better-auth").RawError<"INVALID_REFERENCE_ID_FROM_API_KEY">;
+            INVALID_API_KEY_GETTER_RETURN_TYPE: import("better-auth").RawError<"INVALID_API_KEY_GETTER_RETURN_TYPE">;
+            SERVER_ONLY_PROPERTY: import("better-auth").RawError<"SERVER_ONLY_PROPERTY">;
+            FAILED_TO_UPDATE_API_KEY: import("better-auth").RawError<"FAILED_TO_UPDATE_API_KEY">;
+            NAME_REQUIRED: import("better-auth").RawError<"NAME_REQUIRED">;
+            ORGANIZATION_ID_REQUIRED: import("better-auth").RawError<"ORGANIZATION_ID_REQUIRED">;
+            USER_NOT_MEMBER_OF_ORGANIZATION: import("better-auth").RawError<"USER_NOT_MEMBER_OF_ORGANIZATION">;
+            INSUFFICIENT_API_KEY_PERMISSIONS: import("better-auth").RawError<"INSUFFICIENT_API_KEY_PERMISSIONS">;
+            NO_DEFAULT_API_KEY_CONFIGURATION_FOUND: import("better-auth").RawError<"NO_DEFAULT_API_KEY_CONFIGURATION_FOUND">;
+            ORGANIZATION_PLUGIN_REQUIRED: import("better-auth").RawError<"ORGANIZATION_PLUGIN_REQUIRED">;
+        };
+        hooks: {
+            before: {
+                matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
+                handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                    session: {
+                        id: string;
+                        token: string;
+                        userId: string;
+                        userAgent: string | null;
+                        ipAddress: string | null;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        expiresAt: Date;
+                    };
+                } | {
+                    context: import("better-auth").MiddlewareContext<import("better-auth").MiddlewareOptions, import("better-auth").PluginContext<BetterAuthOptions> & import("better-auth").InfoContext & {
+                        options: BetterAuthOptions;
+                        trustedOrigins: string[];
+                        trustedProviders: string[];
+                        isTrustedOrigin: (url: string, settings?: {
+                            allowRelativePaths: boolean;
+                        }) => boolean;
+                        oauthConfig: {
+                            skipStateCookieCheck?: boolean | undefined;
+                            storeStateStrategy: "database" | "cookie";
+                        };
+                        newSession: {
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            } & Record<string, any>;
+                            user: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            } & Record<string, any>;
+                        } | null;
+                        session: {
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            } & Record<string, any>;
+                            user: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            } & Record<string, any>;
+                        } | null;
+                        setNewSession: (session: {
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            } & Record<string, any>;
+                            user: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            } & Record<string, any>;
+                        } | null) => void;
+                        socialProviders: import("better-auth").OAuthProvider[];
+                        authCookies: import("better-auth").BetterAuthCookies;
+                        logger: ReturnType<(options?: import("better-auth").Logger | undefined) => import("better-auth").InternalLogger>;
+                        rateLimit: {
+                            enabled: boolean;
+                            window: number;
+                            max: number;
+                            storage: "memory" | "database" | "secondary-storage";
+                        } & Omit<import("better-auth").BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
+                        adapter: import("better-auth").DBAdapter<BetterAuthOptions>;
+                        internalAdapter: import("better-auth").InternalAdapter<BetterAuthOptions>;
+                        createAuthCookie: (cookieName: string, overrideAttributes?: Partial<import("better-auth").CookieOptions> | undefined) => import("better-auth").BetterAuthCookie;
+                        secret: string;
+                        secretConfig: string | import("better-auth").SecretConfig;
+                        sessionConfig: {
+                            updateAge: number;
+                            expiresIn: number;
+                            freshAge: number;
+                            cookieCacheSigner?: import("better-auth").CookieCacheSigner | undefined;
+                            cookieRefreshCache: false | {
+                                enabled: true;
+                                updateAge: number;
+                            };
+                        };
+                        generateId: (options: {
+                            model: import("better-auth").ModelNames;
+                            size?: number | undefined;
+                        }) => string | false;
+                        secondaryStorage: import("better-auth").SecondaryStorage | undefined;
+                        password: {
+                            hash: (password: string) => Promise<string>;
+                            verify: (data: {
+                                password: string;
+                                hash: string;
+                            }) => Promise<boolean>;
+                            config: {
+                                minPasswordLength: number;
+                                maxPasswordLength: number;
+                            };
+                            checkPassword: (userId: string, ctx: import("better-auth").GenericEndpointContext<BetterAuthOptions>) => Promise<boolean>;
+                        };
+                        tables: import("better-auth").BetterAuthDBSchema;
+                        runMigrations: () => Promise<void>;
+                        publishTelemetry: (event: {
+                            type: string;
+                            anonymousId?: string | undefined;
+                            payload: Record<string, any>;
+                        }) => Promise<void>;
+                        skipOriginCheck: boolean | string[];
+                        skipCSRFCheck: boolean;
+                        runInBackground: (promise: Promise<unknown>) => void;
+                        runInBackgroundOrAwait: (promise: Promise<unknown> | void) => import("better-auth").Awaitable<unknown>;
+                    } & {
+                        returned?: unknown | undefined;
+                        responseHeaders?: Headers | undefined;
+                    }>;
+                }>>;
+            }[];
+        };
+        endpoints: {
+            createApiKey: import("better-auth").StrictEndpoint<"/api-key/create", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    configId: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    expiresIn: import("better-auth").ZodDefault<import("better-auth").ZodNullable<import("better-auth").ZodOptional<import("better-auth").ZodNumber>>>;
+                    prefix: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    remaining: import("better-auth").ZodDefault<import("better-auth").ZodNullable<import("better-auth").ZodOptional<import("better-auth").ZodNumber>>>;
+                    metadata: import("better-auth").ZodOptional<import("better-auth").ZodAny>;
+                    refillAmount: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
+                    refillInterval: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
+                    rateLimitTimeWindow: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
+                    rateLimitMax: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
+                    rateLimitEnabled: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    permissions: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>>>;
+                    userId: import("better-auth").ZodOptional<import("better-auth").ZodCoercedString<unknown>>;
+                    organizationId: import("better-auth").ZodOptional<import("better-auth").ZodCoercedString<unknown>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                createdAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                updatedAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                name: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                prefix: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                start: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                key: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                enabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                expiresAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                referenceId: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                lastRefillAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRequest: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                metadata: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    additionalProperties: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitMax: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitTimeWindow: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                remaining: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                refillAmount: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                refillInterval: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitEnabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                requestCount: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                permissions: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    additionalProperties: {
+                                                        type: string;
+                                                        items: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                key: string;
+                metadata: any;
+                permissions: any;
+                id: string;
+                configId: string;
+                name: string | null;
+                start: string | null;
+                prefix: string | null;
+                referenceId: string;
+                refillInterval: number | null;
+                refillAmount: number | null;
+                lastRefillAt: Date | null;
+                enabled: boolean;
+                rateLimitEnabled: boolean;
+                rateLimitTimeWindow: number | null;
+                rateLimitMax: number | null;
+                requestCount: number;
+                remaining: number | null;
+                lastRequest: Date | null;
+                expiresAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date;
+            }>;
+            verifyApiKey: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    configId: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    key: import("better-auth").ZodString;
+                    permissions: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>>>;
+                }, import("zod/v4/core").$strip>;
+            }, {
+                valid: boolean;
+                error: {
+                    message: import("better-auth").RawError<"INVALID_API_KEY">;
+                    code: "KEY_NOT_FOUND";
+                };
+                key: null;
+            } | {
+                valid: boolean;
+                error: {
+                    message: string | undefined;
+                    code: string;
+                    cause?: unknown;
+                };
+                key: null;
+            } | {
+                valid: boolean;
+                error: {
+                    message: import("better-auth").RawError<"INVALID_API_KEY">;
+                    code: "INVALID_API_KEY";
+                };
+                key: null;
+            } | {
+                valid: boolean;
+                error: null;
+                key: Omit<import("@better-auth/api-key").ApiKey, "key"> | null;
+            }>;
+            getApiKey: import("better-auth").StrictEndpoint<"/api-key/get", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    configId: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    id: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").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: {
+                                                id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                name: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                start: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                prefix: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                userId: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                refillInterval: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                refillAmount: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRefillAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                enabled: {
+                                                    type: string;
+                                                    description: string;
+                                                    default: boolean;
+                                                };
+                                                rateLimitEnabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                rateLimitTimeWindow: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitMax: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                requestCount: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                remaining: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRequest: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                expiresAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                createdAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                updatedAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                metadata: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    additionalProperties: boolean;
+                                                    description: string;
+                                                };
+                                                permissions: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                metadata: Record<string, any> | null;
+                permissions: {
+                    [key: string]: string[];
+                } | null;
+                id: string;
+                configId: string;
+                name: string | null;
+                start: string | null;
+                prefix: string | null;
+                referenceId: string;
+                refillInterval: number | null;
+                refillAmount: number | null;
+                lastRefillAt: Date | null;
+                enabled: boolean;
+                rateLimitEnabled: boolean;
+                rateLimitTimeWindow: number | null;
+                rateLimitMax: number | null;
+                requestCount: number;
+                remaining: number | null;
+                lastRequest: Date | null;
+                expiresAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date;
+            }>;
+            updateApiKey: import("better-auth").StrictEndpoint<"/api-key/update", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    configId: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    keyId: import("better-auth").ZodString;
+                    userId: import("better-auth").ZodOptional<import("better-auth").ZodCoercedString<unknown>>;
+                    name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    enabled: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    remaining: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
+                    refillAmount: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
+                    refillInterval: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
+                    metadata: import("better-auth").ZodOptional<import("better-auth").ZodAny>;
+                    expiresIn: import("better-auth").ZodNullable<import("better-auth").ZodOptional<import("better-auth").ZodNumber>>;
+                    rateLimitEnabled: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    rateLimitTimeWindow: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
+                    rateLimitMax: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
+                    permissions: import("better-auth").ZodNullable<import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>>>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                name: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                start: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                prefix: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                userId: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                refillInterval: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                refillAmount: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRefillAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                enabled: {
+                                                    type: string;
+                                                    description: string;
+                                                    default: boolean;
+                                                };
+                                                rateLimitEnabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                rateLimitTimeWindow: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                rateLimitMax: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                requestCount: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                remaining: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                lastRequest: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                expiresAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                createdAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                updatedAt: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                metadata: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    additionalProperties: boolean;
+                                                    description: string;
+                                                };
+                                                permissions: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                metadata: Record<string, any> | null;
+                permissions: {
+                    [key: string]: string[];
+                } | null;
+                id: string;
+                configId: string;
+                name: string | null;
+                start: string | null;
+                prefix: string | null;
+                referenceId: string;
+                refillInterval: number | null;
+                refillAmount: number | null;
+                lastRefillAt: Date | null;
+                enabled: boolean;
+                rateLimitEnabled: boolean;
+                rateLimitTimeWindow: number | null;
+                rateLimitMax: number | null;
+                requestCount: number;
+                remaining: number | null;
+                lastRequest: Date | null;
+                expiresAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date;
+            }>;
+            deleteApiKey: import("better-auth").StrictEndpoint<"/api-key/delete", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    configId: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    keyId: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").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;
+                        requestBody: {
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            keyId: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                        };
+                                        required: string[];
+                                    };
+                                };
+                            };
+                        };
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            listApiKeys: import("better-auth").StrictEndpoint<"/api-key/list", {
+                method: "GET";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").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;
+                        };
+                    };
+                }>>[];
+                query: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
+                    configId: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    organizationId: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    limit: import("better-auth").ZodOptional<import("better-auth").ZodCoercedNumber<unknown>>;
+                    offset: import("better-auth").ZodOptional<import("better-auth").ZodCoercedNumber<unknown>>;
+                    sortBy: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    sortDirection: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, import("zod/v4/core").$strip>>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                apiKeys: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        properties: {
+                                                            id: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            name: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            start: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            prefix: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            userId: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            refillInterval: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            refillAmount: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            lastRefillAt: {
+                                                                type: string;
+                                                                format: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            enabled: {
+                                                                type: string;
+                                                                description: string;
+                                                                default: boolean;
+                                                            };
+                                                            rateLimitEnabled: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            rateLimitTimeWindow: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            rateLimitMax: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            requestCount: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            remaining: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            lastRequest: {
+                                                                type: string;
+                                                                format: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            expiresAt: {
+                                                                type: string;
+                                                                format: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            createdAt: {
+                                                                type: string;
+                                                                format: string;
+                                                                description: string;
+                                                            };
+                                                            updatedAt: {
+                                                                type: string;
+                                                                format: string;
+                                                                description: string;
+                                                            };
+                                                            metadata: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                additionalProperties: boolean;
+                                                                description: string;
+                                                            };
+                                                            permissions: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                                total: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                limit: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                offset: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                apiKeys: {
+                    metadata: Record<string, any> | null;
+                    permissions: {
+                        [key: string]: string[];
+                    } | null;
+                    id: string;
+                    configId: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    referenceId: string;
+                    refillInterval: number | null;
+                    refillAmount: number | null;
+                    lastRefillAt: Date | null;
+                    enabled: boolean;
+                    rateLimitEnabled: boolean;
+                    rateLimitTimeWindow: number | null;
+                    rateLimitMax: number | null;
+                    requestCount: number;
+                    remaining: number | null;
+                    lastRequest: Date | null;
+                    expiresAt: Date | null;
+                    createdAt: Date;
+                    updatedAt: Date;
+                }[];
+                total: number;
+                limit: number | undefined;
+                offset: number | undefined;
+            }>;
+            deleteAllExpiredApiKeys: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+            }, {
+                success: boolean;
+                error: unknown;
+            }>;
+        };
+        schema: {
+            apikey: {
+                fields: {
+                    configId: {
+                        type: "string";
+                        required: true;
+                        defaultValue: string;
+                        input: false;
+                        index: true;
+                    };
+                    name: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    start: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    referenceId: {
+                        type: "string";
+                        required: true;
+                        input: false;
+                        index: true;
+                    };
+                    prefix: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    key: {
+                        type: "string";
+                        required: true;
+                        input: false;
+                        index: true;
+                    };
+                    refillInterval: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                    };
+                    refillAmount: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                    };
+                    lastRefillAt: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                    enabled: {
+                        type: "boolean";
+                        required: false;
+                        input: false;
+                        defaultValue: true;
+                    };
+                    rateLimitEnabled: {
+                        type: "boolean";
+                        required: false;
+                        input: false;
+                        defaultValue: true;
+                    };
+                    rateLimitTimeWindow: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                        defaultValue: number;
+                    };
+                    rateLimitMax: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                        defaultValue: number;
+                    };
+                    requestCount: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                        defaultValue: number;
+                    };
+                    remaining: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                    };
+                    lastRequest: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                    expiresAt: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                        input: false;
+                    };
+                    updatedAt: {
+                        type: "date";
+                        required: true;
+                        input: false;
+                    };
+                    permissions: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    metadata: {
+                        type: "string";
+                        required: false;
+                        input: true;
+                        transform: {
+                            input(value: import("better-auth").DBPrimitive): string;
+                            output(value: import("better-auth").DBPrimitive): any;
+                        };
+                    };
+                };
+            };
+        };
+    }, {
+        id: "phone-number";
+        version: string;
+        init(): {
+            options: {
+                databaseHooks: {
+                    user: {
+                        update: {
+                            before(data: Partial<{
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            }> & Record<string, unknown>): Promise<{
+                                data: {
+                                    [x: string]: unknown;
+                                    id?: string | undefined;
+                                    createdAt?: Date | undefined;
+                                    updatedAt?: Date | undefined;
+                                    email?: string | undefined;
+                                    emailVerified?: boolean | undefined;
+                                    name?: string | undefined;
+                                    image?: string | null | undefined;
+                                };
+                            } | undefined>;
+                        };
+                    };
+                };
+            };
+        };
+        hooks: {
+            before: {
+                matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
+                handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<never>>;
+            }[];
+        };
+        endpoints: {
+            signInPhoneNumber: import("better-auth").StrictEndpoint<"/sign-in/phone-number", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    phoneNumber: import("better-auth").ZodString;
+                    password: import("better-auth").ZodString;
+                    rememberMe: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            400: {
+                                description: string;
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: import("better-auth/plugins").UserWithPhoneNumber;
+            }>;
+            sendPhoneNumberOTP: import("better-auth").StrictEndpoint<"/phone-number/send-otp", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    phoneNumber: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                message: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                message: string;
+            }>;
+            consumePhoneNumberOTP: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    phoneNumber: import("better-auth").ZodString;
+                    code: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    readonly scope: "server";
+                };
+            }, {
+                status: boolean;
+            }>;
+            verifyPhoneNumber: import("better-auth").StrictEndpoint<"/phone-number/verify", {
+                method: "POST";
+                body: import("better-auth").ZodIntersection<import("better-auth").ZodObject<{
+                    phoneNumber: import("better-auth").ZodString;
+                    code: import("better-auth").ZodString;
+                    disableSession: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    updatePhoneNumber: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                }, import("zod/v4/core").$strip>, import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodAny>>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                                token: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    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;
+                                                        };
+                                                        phoneNumber: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        phoneNumberVerified: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        updatedAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            400: {
+                                description: string;
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & import("better-auth/plugins").UserWithPhoneNumber;
+            } | {
+                status: boolean;
+                token: null;
+                user: import("better-auth/plugins").UserWithPhoneNumber;
+            }>;
+            requestPasswordResetPhoneNumber: import("better-auth").StrictEndpoint<"/phone-number/request-password-reset", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    phoneNumber: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            resetPasswordPhoneNumber: import("better-auth").StrictEndpoint<"/phone-number/reset-password", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    otp: import("better-auth").ZodString;
+                    phoneNumber: import("better-auth").ZodString;
+                    newPassword: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+        };
+        schema: {
+            user: {
+                fields: {
+                    phoneNumber: {
+                        type: "string";
+                        required: false;
+                        unique: true;
+                        sortable: true;
+                        returned: true;
+                    };
+                    phoneNumberVerified: {
+                        type: "boolean";
+                        required: false;
+                        returned: true;
+                        input: false;
+                    };
+                };
+            };
+        };
+        rateLimit: {
+            pathMatcher(path: string): boolean;
+            window: number;
+            max: number;
+        }[];
+        options: import("better-auth/plugins").PhoneNumberOptions | undefined;
+        $ERROR_CODES: {
+            OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+            INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+            TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+            INVALID_PHONE_NUMBER: import("better-auth").RawError<"INVALID_PHONE_NUMBER">;
+            PHONE_NUMBER_EXIST: import("better-auth").RawError<"PHONE_NUMBER_EXIST">;
+            PHONE_NUMBER_NOT_EXIST: import("better-auth").RawError<"PHONE_NUMBER_NOT_EXIST">;
+            INVALID_PHONE_NUMBER_OR_PASSWORD: import("better-auth").RawError<"INVALID_PHONE_NUMBER_OR_PASSWORD">;
+            UNEXPECTED_ERROR: import("better-auth").RawError<"UNEXPECTED_ERROR">;
+            OTP_NOT_FOUND: import("better-auth").RawError<"OTP_NOT_FOUND">;
+            PHONE_NUMBER_NOT_VERIFIED: import("better-auth").RawError<"PHONE_NUMBER_NOT_VERIFIED">;
+            PHONE_NUMBER_CANNOT_BE_UPDATED: import("better-auth").RawError<"PHONE_NUMBER_CANNOT_BE_UPDATED">;
+            SEND_OTP_NOT_IMPLEMENTED: import("better-auth").RawError<"SEND_OTP_NOT_IMPLEMENTED">;
+        };
+    }];
+    user: {
+        additionalFields: {
+            vendorId: {
+                type: "string";
+                required: false;
+            };
+            posOperatorPin: {
+                type: "string";
+                required: false;
+            };
+        };
+    };
+};
+export type AuthSchemaParityMismatch = {
+    model: string;
+    field: string;
+    issue: string;
+};
+/**
+ * Returns every mismatch between better-auth's expected auth tables and the
+ * Drizzle definitions Porulle ships. An empty array means parity holds.
+ */
+export declare function findAuthSchemaParityMismatches(options?: BetterAuthOptions): AuthSchemaParityMismatch[];
+export declare function assertAuthSchemaParity(options?: BetterAuthOptions): void;
+//# sourceMappingURL=auth-schema-guard.d.ts.map