@antasphere/chassis-server 1.0.0

package/dist/identity/better-auth.d.ts

@@ -0,0 +1,3927 @@
+import { type Db } from '@antasphere/chassis-db';
+import type { Env } from '../env.js';
+import { type HubSsoService } from './hub-sso.js';
+import { type DemoPassPluginDeps } from './demo-pass-plugin.js';
+/**
+ * The only file that touches better-auth's constructor. Everything else goes
+ * through the identity module's exports or the IdentityProvider seam, so a
+ * Better Auth upgrade (or replacement) stays contained.
+ *
+ * Password login is the self-host default (no SMTP dependency). Email OTP
+ * auto-enables when an email driver is configured; Google when client
+ * credentials are set. The twoFactor plugin offers OPT-IN per-user TOTP +
+ * backup codes (ADR 009) — password and email-OTP sign-ins by an enrolled
+ * user require the second factor; machine credentials never see one. The
+ * jwt + oauthProvider plugins make every instance an OAuth 2.1 authorization
+ * server for its own bundled /mcp endpoint (M6): RS256 access JWTs (15 min),
+ * rotating refresh tokens, PKCE + dynamic client registration, issuance
+ * gated on a LIVE active workspace membership.
+ */
+/** Credential events audited on Better-Auth-native routes. */
+export type AccountEvent = 'password_reset' | 'password_change' | 'email_change_request' | 'email_change' | 'two_factor_enroll' | 'two_factor_disable';
+export interface CreateAuthOptions {
+    db: Db;
+    env: Pick<Env, 'PUBLIC_BASE_URL' | 'GOOGLE_CLIENT_ID' | 'GOOGLE_CLIENT_SECRET' | 'OAUTH_DYNAMIC_CLIENT_REGISTRATION' | 'SUPERADMIN_EMAILS'>;
+    authSecret: string;
+    /**
+     * The tool's OAuth scope list, in the ORDER it is published (discovery
+     * `scopes_supported`, the consent screen, client registration defaults).
+     * The chassis spells no scope name: the tool defines the list and hands it
+     * in; the well-known documents read the same array from the tool.
+     */
+    oauthScopes: readonly string[];
+    /**
+     * Origins that are NEVER trusted, serving origin or not (PRDCT-1352): each
+     * is filtered out of `trustedOrigins` and refused outright by the sign-in
+     * Origin lock. Empty = nothing installed. A tool with a viewer passes its
+     * viewer origin (author-controlled script runs there).
+     */
+    untrustedOrigins: readonly string[];
+    /** When provided (an email driver delivers), the email-OTP login auto-enables. */
+    sendOtp?: (params: {
+        email: string;
+        otp: string;
+        type: string;
+    }) => Promise<void>;
+    /**
+     * When provided (an email driver delivers), self-serve password reset
+     * auto-enables — POST /request-password-reset mails a link. Without it that
+     * endpoint stays closed (400) and only the admin-generated reset link works.
+     * On EDITION=cloud it is IGNORED: the whole reset surface refuses there
+     * (D1 hub-only posture — see isPasswordResetPath and the before-hook).
+     */
+    sendResetPassword?: (params: {
+        email: string;
+        url: string;
+        token: string;
+    }) => Promise<void>;
+    /**
+     * Confirmation mail to the OLD address when a VERIFIED user requests an
+     * email change (the two-leg flow). Unverified users — the template's common
+     * case — skip straight to the verification mail below.
+     */
+    sendChangeEmailConfirmation?: (params: {
+        email: string;
+        newEmail: string;
+        url: string;
+        token: string;
+    }) => Promise<void>;
+    /**
+     * Verification mail to the NEW address — the final leg of every self-serve
+     * email change. When provided (an email driver delivers), POST /change-email
+     * opens; without it the endpoint answers 400 BEFORE any email lookup (no
+     * enumeration oracle) and only the admin-generated change link works.
+     */
+    sendVerificationEmail?: (params: {
+        email: string;
+        url: string;
+        token: string;
+    }) => Promise<void>;
+    /**
+     * Audit hook for credential events on Better-Auth-native routes (which
+     * bypass the /api/v1 audit middleware). Fired best-effort by the caller.
+     */
+    onAccountEvent?: (event: AccountEvent, userId: string) => Promise<void>;
+    /**
+     * Fired from Better Auth's databaseHooks.user.create.after — the ONE seam
+     * every account entrance passes through (setup, invitation accept, the
+     * collaborator claim endpoint, any future SSO JIT), so a `user.created`
+     * event is trustworthy by construction instead of depending on each call
+     * site remembering to emit. Boot wires this to the platform event bus.
+     */
+    onUserCreated?: (user: {
+        id: string;
+        email: string;
+    }) => void;
+    /**
+     * Self-service account deletion guard, run by POST /delete-user BEFORE the
+     * row cascade. Boot wires the AccountDeletionService here and translates
+     * LastOwnerError into an APIError('BAD_REQUEST') so the route answers 400.
+     */
+    beforeUserDelete?: (userId: string) => Promise<void>;
+    /** Completion hook, run AFTER the cascade (the audit row's system actor). */
+    afterUserDelete?: (user: {
+        id: string;
+        email: string;
+    }) => Promise<void>;
+    /**
+     * The cloud edition's hub SSO binding (internal/federation.md, ADR 015).
+     * Present ONLY when the instance boots EDITION=cloud: registers the
+     * `antasphere` genericOAuth relying party, the D9 trusted-link config,
+     * and the per-login callback after-hook (JIT projection + re-sync). An
+     * oss boot passes nothing and carries zero SSO surface at runtime.
+     */
+    hubSso?: HubSsoService | undefined;
+    /**
+     * Demo sign-in (identity/demo-pass-plugin.ts): handed in by boot only while
+     * DEMO_SIGN_IN is on. The redeem endpoint is registered only then, and
+     * only on the self-hosted edition.
+     */
+    demoPass?: DemoPassPluginDeps | undefined;
+}
+export declare const AUTH_BASE_PATH = "/api/v1/auth";
+/**
+ * The canonical OAuth resource identifier (JWT `aud`, RFC 8707) — the bundled
+ * MCP endpoint. Derived from PUBLIC_BASE_URL at boot, never from its own env
+ * var: AS and resource live on one origin, so the byte-identical-URL footgun
+ * of the split dashboard+MCP deployment cannot exist here.
+ */
+export declare function mcpResourceUrl(publicBaseUrl: string): string;
+export type Auth = ReturnType<typeof createAuth>;
+/**
+ * Better Auth `trustedOrigins` (PRDCT-1352): the configured public origin plus
+ * the origin the request was served on (localhost, previews, any domain behind
+ * a TLS-terminating proxy) — MINUS the viewer origin, which is author-
+ * controlled script's origin and is never trusted, serving origin or
+ * not. The host gate keeps the auth surface off that hostname; this is the
+ * second lock behind it. Exported pure so a unit test can pin the exclusion.
+ */
+export declare function trustedOriginsFor(publicBaseUrl: string, untrustedOrigins: readonly string[]): (request?: Request) => string[];
+/**
+ * The sign-in Origin lock (M9 login-CSRF hardening + PRDCT-1352): a sign-in
+ * that presents an Origin must present a trusted one — the serving origin or
+ * Better Auth's own trusted list — and the viewer origin is refused OUTRIGHT,
+ * even as the serving origin: author script must never mint a session on the
+ * hostname it runs on. Exported pure so a unit test can pin both arms.
+ */
+export declare function signInOriginRefused(input: {
+    origin: string;
+    servingOrigin: string | null;
+    untrustedOrigins: readonly string[];
+    isTrustedOrigin: (origin: string) => boolean;
+}): boolean;
+export declare function createAuth({ db, env, authSecret, oauthScopes, untrustedOrigins, sendOtp, sendResetPassword, sendChangeEmailConfirmation, sendVerificationEmail, onAccountEvent, onUserCreated, beforeUserDelete, afterUserDelete, hubSso, demoPass }: CreateAuthOptions): import("better-auth").Auth<{
+    database: (options: import("@better-auth/core").BetterAuthOptions) => import("@better-auth/core/db/adapter").DBAdapter<import("@better-auth/core").BetterAuthOptions>;
+    user: {
+        changeEmail: {
+            sendChangeEmailConfirmation?: ({ user, newEmail, url, token }: {
+                user: {
+                    email: string;
+                };
+                newEmail: string;
+                url: string;
+                token: string;
+            }) => Promise<void>;
+            enabled: true;
+        };
+        deleteUser: {
+            enabled: true;
+            beforeDelete: (user: {
+                id: string;
+            }) => Promise<void>;
+            afterDelete: (user: {
+                id: string;
+                email: string;
+            }) => Promise<void>;
+        };
+    };
+    emailVerification: {
+        afterEmailVerification: (user: {
+            id: string;
+        }) => Promise<void>;
+        sendVerificationEmail?: ({ user, url, token }: {
+            user: {
+                email: string;
+            };
+            url: string;
+            token: string;
+        }) => Promise<void>;
+        expiresIn: number;
+    };
+    emailAndPassword: {
+        resetPasswordTokenExpiresIn?: number;
+        sendResetPassword?: ({ user, url, token }: {
+            user: {
+                email: string;
+            };
+            url: string;
+            token: string;
+        }) => Promise<void>;
+        enabled: true;
+        minPasswordLength: number;
+        revokeSessionsOnPasswordReset: true;
+        onPasswordReset: ({ user }: {
+            user: {
+                id: string;
+            };
+        }) => Promise<void>;
+    };
+    hooks: {
+        before: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+        after: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+            twoFactorRedirect: boolean;
+            twoFactorMethods: string[];
+        } | undefined>;
+    };
+    databaseHooks: {
+        user: {
+            create: {
+                after: (user: {
+                    id: string;
+                    email: string;
+                }) => Promise<void>;
+            };
+        };
+    };
+    session: {
+        expiresIn: number;
+        disableSessionRefresh: true;
+        updateAge?: never;
+    } | {
+        expiresIn: number;
+        updateAge: number;
+        disableSessionRefresh?: never;
+    };
+    advanced: {
+        useSecureCookies: boolean;
+    };
+    rateLimit: {
+        window: number;
+        max: number;
+        customRules: {
+            '/sign-in/oauth2': {
+                window: number;
+                max: number;
+            };
+        };
+    };
+    trustedOrigins: (request?: Request) => string[];
+    onAPIError?: {
+        errorURL: string;
+    };
+    plugins: [...(import("better-auth").BetterAuthPlugin | {
+        id: "generic-oauth";
+        version: string;
+        init: (ctx: import("better-auth").AuthContext) => {
+            context: {
+                socialProviders: import("better-auth").OAuthProvider<Record<string, any>, Partial<import("better-auth").ProviderOptions<any>>>[];
+            };
+        };
+        endpoints: {
+            signInWithOAuth2: import("better-auth").StrictEndpoint<"/sign-in/oauth2", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    providerId: import("better-auth").ZodString;
+                    callbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    errorCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    newUserCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    disableRedirect: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    scopes: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    requestSignUp: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    additionalData: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodAny>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                url: {
+                                                    type: string;
+                                                };
+                                                redirect: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                url: string;
+                redirect: boolean;
+            }>;
+            oAuth2Callback: import("better-auth").StrictEndpoint<"/oauth2/callback/:providerId", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    code: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    error: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    error_description: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    state: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    iss: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    allowedMediaTypes: string[];
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                url: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    scope: "server";
+                };
+            }, never>;
+            oAuth2LinkAccount: import("better-auth").StrictEndpoint<"/oauth2/link", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    providerId: import("better-auth").ZodString;
+                    callbackURL: import("better-auth").ZodString;
+                    scopes: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    errorCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((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: {
+                                                url: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                redirect: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                url: string;
+                redirect: boolean;
+            }>;
+        };
+        options: import("better-auth/plugins").GenericOAuthOptions;
+        $ERROR_CODES: {
+            INVALID_OAUTH_CONFIGURATION: import("better-auth").RawError<"INVALID_OAUTH_CONFIGURATION">;
+            TOKEN_URL_NOT_FOUND: import("better-auth").RawError<"TOKEN_URL_NOT_FOUND">;
+            PROVIDER_CONFIG_NOT_FOUND: import("better-auth").RawError<"PROVIDER_CONFIG_NOT_FOUND">;
+            PROVIDER_ID_REQUIRED: import("better-auth").RawError<"PROVIDER_ID_REQUIRED">;
+            INVALID_OAUTH_CONFIG: import("better-auth").RawError<"INVALID_OAUTH_CONFIG">;
+            SESSION_REQUIRED: import("better-auth").RawError<"SESSION_REQUIRED">;
+            ISSUER_MISMATCH: import("better-auth").RawError<"ISSUER_MISMATCH">;
+            ISSUER_MISSING: import("better-auth").RawError<"ISSUER_MISSING">;
+        };
+    } | {
+        id: "email-otp";
+        version: string;
+        init(ctx: import("better-auth").AuthContext): {
+            options: {
+                emailVerification: {
+                    sendVerificationEmail(data: {
+                        user: import("better-auth").User;
+                        url: string;
+                        token: string;
+                    }, request: Request | undefined): Promise<void>;
+                };
+            };
+        } | undefined;
+        endpoints: {
+            sendVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/send-verification-otp", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                    type: import("better-auth").ZodEnum<{
+                        "sign-in": "sign-in";
+                        "change-email": "change-email";
+                        "email-verification": "email-verification";
+                        "forget-password": "forget-password";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            createVerificationOTP: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                    type: import("better-auth").ZodEnum<{
+                        "sign-in": "sign-in";
+                        "change-email": "change-email";
+                        "email-verification": "email-verification";
+                        "forget-password": "forget-password";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "string";
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, string>;
+            getVerificationOTP: import("better-auth").StrictEndpoint<string, {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                    type: import("better-auth").ZodEnum<{
+                        "sign-in": "sign-in";
+                        "change-email": "change-email";
+                        "email-verification": "email-verification";
+                        "forget-password": "forget-password";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                otp: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                otp: null;
+            } | {
+                otp: string;
+            }>;
+            checkVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/check-verification-otp", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                    type: import("better-auth").ZodEnum<{
+                        "sign-in": "sign-in";
+                        "change-email": "change-email";
+                        "email-verification": "email-verification";
+                        "forget-password": "forget-password";
+                    }>;
+                    otp: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            verifyEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/verify-email", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                    otp: 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[];
+                                                };
+                                                token: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, any>;
+            } | {
+                status: boolean;
+                token: null;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, any>;
+            }>;
+            signInEmailOTP: import("better-auth").StrictEndpoint<"/sign-in/email-otp", {
+                method: "POST";
+                body: import("better-auth").ZodIntersection<import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                    otp: import("better-auth").ZodString;
+                    name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    image: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>, import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodAny>>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }>;
+            requestPasswordResetEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-password-reset", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            forgetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/forget-password/email-otp", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            resetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/reset-password", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodString;
+                    otp: import("better-auth").ZodString;
+                    password: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            requestEmailChangeEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/request-email-change", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    newEmail: import("better-auth").ZodString;
+                    otp: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((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: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            changeEmailEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/change-email", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    newEmail: import("better-auth").ZodString;
+                    otp: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((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: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+        };
+        hooks: {
+            after: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        rateLimit: ({
+            pathMatcher(path: string): path is "/email-otp/send-verification-otp";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/check-verification-otp";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/verify-email";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/sign-in/email-otp";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/request-password-reset";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/reset-password";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/forget-password/email-otp";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/request-email-change";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/change-email";
+            window: number;
+            max: number;
+        })[];
+        options: import("better-auth/plugins").EmailOTPOptions;
+        $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">;
+        };
+    })[], {
+        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>;
+                    issuer: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip> | import("better-auth").ZodObject<{
+                    password: import("better-auth").ZodString;
+                    issuer: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((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: {
+                                                totpURI: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                backupCodes: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                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: ((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: ((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: ((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: (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_HAS_EXPIRED: import("better-auth").RawError<"OTP_HAS_EXPIRED">;
+            TOTP_NOT_ENABLED: import("better-auth").RawError<"TOTP_NOT_ENABLED">;
+            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: "jwt";
+        version: string;
+        options: NoInfer<{
+            disableSettingJwtHeader: true;
+            jwks: {
+                keyPairConfig: {
+                    alg: "RS256";
+                };
+            };
+            jwt: {
+                issuer: string;
+            };
+        }>;
+        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: ((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: (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;
+                    };
+                };
+            };
+        };
+    }, {
+        id: "oauth-provider";
+        version: string;
+        options: NoInfer<{
+            loginPage: string;
+            consentPage: string;
+            scopes: string[];
+            validAudiences: string[];
+            grantTypes: ("refresh_token" | "authorization_code")[];
+            allowDynamicClientRegistration: boolean;
+            allowUnauthenticatedClientRegistration: boolean;
+            clientRegistrationDefaultScopes: string[];
+            clientRegistrationAllowedScopes: string[];
+            accessTokenExpiresIn: number;
+            refreshTokenExpiresIn: number;
+            customAccessTokenClaims: ({ user }: {
+                user?: ({
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, unknown>) | null;
+                referenceId?: string;
+                scopes: import("@better-auth/oauth-provider").Scope[];
+                resource?: string;
+                metadata?: Record<string, any>;
+            }) => Promise<{
+                email: string;
+            }>;
+            postLogin: {
+                page: string;
+                shouldRedirect: () => false;
+                consentReferenceId: () => Promise<undefined>;
+            };
+            silenceWarnings: {
+                oauthAuthServerConfig: true;
+                openidConfig: true;
+            };
+        }>;
+        init: (ctx: import("better-auth").AuthContext) => void;
+        onRequest: (request: Request, ctx: import("better-auth").AuthContext) => Promise<{
+            response: Response;
+        } | {
+            request: Request;
+        } | void>;
+        hooks: {
+            before: {
+                matcher(ctx: import("better-auth").HookEndpointContext): any;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+            }[];
+            after: {
+                matcher(ctx: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    redirect: boolean;
+                    url: string;
+                } | undefined>;
+            }[];
+        };
+        endpoints: {
+            getOAuthServerConfig: import("better-call").StrictEndpoint<"/.well-known/oauth-authorization-server", {
+                method: "GET";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").AuthServerMetadata>;
+            getOpenIdConfig: import("better-call").StrictEndpoint<"/.well-known/openid-configuration", {
+                method: "GET";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, Omit<import("@better-auth/oauth-provider").OIDCMetadata, "id_token_signing_alg_values_supported"> & {
+                id_token_signing_alg_values_supported: import("better-auth/plugins").JWSAlgorithms[] | ["HS256"];
+            }>;
+            oauth2Authorize: import("better-call").StrictEndpoint<"/oauth2/authorize", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    response_type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        code: "code";
+                    }>>;
+                    client_id: import("better-auth").ZodString;
+                    redirect_uri: import("better-auth").ZodOptional<import("better-auth").ZodURL>;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    state: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    request_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    code_challenge: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    code_challenge_method: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        S256: "S256";
+                    }>>;
+                    nonce: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    prompt: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        none: "none";
+                        consent: "consent";
+                        login: "login";
+                        create: "create";
+                        select_account: "select_account";
+                        "login consent": "login consent";
+                        "select_account consent": "select_account consent";
+                    }>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        parameters: ({
+                            name: string;
+                            in: "query";
+                            required: false;
+                            schema: {
+                                type: "string";
+                                format?: undefined;
+                            };
+                            description: string;
+                        } | {
+                            name: string;
+                            in: "query";
+                            required: true;
+                            schema: {
+                                type: "string";
+                                format?: undefined;
+                            };
+                            description: string;
+                        } | {
+                            name: string;
+                            in: "query";
+                            required: false;
+                            schema: {
+                                type: "string";
+                                format: string;
+                            };
+                            description: string;
+                        })[];
+                        responses: {
+                            "302": {
+                                description: string;
+                                headers: {
+                                    Location: {
+                                        description: string;
+                                        schema: {
+                                            type: string;
+                                            format: string;
+                                        };
+                                    };
+                                };
+                            };
+                            "400": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                error: {
+                                                    type: string;
+                                                };
+                                                error_description: {
+                                                    type: string;
+                                                };
+                                                state: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                redirect: boolean;
+                url: string;
+            }>;
+            oauth2Consent: import("better-call").StrictEndpoint<"/oauth2/consent", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    accept: import("better-auth").ZodBoolean;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    oauth_query: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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: {
+                                                redirect_uri: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                redirect: boolean;
+                url: string;
+            } | {
+                redirect: boolean;
+                url: string;
+            }>;
+            oauth2Continue: import("better-call").StrictEndpoint<"/oauth2/continue", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    selected: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    created: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    postLogin: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    oauth_query: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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: {
+                                                redirect_uri: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                redirect: boolean;
+                url: string;
+            }>;
+            oauth2Token: import("better-call").StrictEndpoint<"/oauth2/token", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    grant_type: import("better-auth").ZodEnum<{
+                        authorization_code: "authorization_code";
+                        client_credentials: "client_credentials";
+                        refresh_token: "refresh_token";
+                    }>;
+                    client_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_secret: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    code: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    code_verifier: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    redirect_uri: import("better-auth").ZodOptional<import("better-auth").ZodURL>;
+                    refresh_token: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    resource: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    allowedMediaTypes: string[];
+                    openapi: {
+                        description: string;
+                        requestBody: {
+                            required: boolean;
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            grant_type: {
+                                                type: string;
+                                                enum: string[];
+                                                description: string;
+                                            };
+                                            client_id: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            client_secret: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            code: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            code_verifier: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            redirect_uri: {
+                                                type: string;
+                                                format: string;
+                                                description: string;
+                                            };
+                                            refresh_token: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            resource: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            scope: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                        };
+                                        required: string[];
+                                    };
+                                };
+                            };
+                        };
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                access_token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                token_type: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                expires_in: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                refresh_token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                scope: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                id_token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            "400": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                error: {
+                                                    type: string;
+                                                };
+                                                error_description: {
+                                                    type: string;
+                                                };
+                                                error_uri: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                access_token: string;
+                expires_in: number;
+                expires_at: number;
+                token_type: "Bearer";
+                refresh_token: string | undefined;
+                scope: string;
+                id_token: string | undefined;
+            }>;
+            oauth2Introspect: import("better-call").StrictEndpoint<"/oauth2/introspect", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    client_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_secret: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    token: import("better-auth").ZodString;
+                    token_type_hint: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        refresh_token: "refresh_token";
+                        access_token: "access_token";
+                    }>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    allowedMediaTypes: string[];
+                    openapi: {
+                        description: string;
+                        requestBody: {
+                            required: boolean;
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            client_id: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            client_secret: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            token: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            token_type_hint: {
+                                                type: string;
+                                                enum: string[];
+                                                description: string;
+                                            };
+                                            resource: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                        };
+                                        required: string[];
+                                    };
+                                };
+                            };
+                        };
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                active: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                scope: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                username: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                token_type: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                exp: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                iat: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                nbf: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                sub: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                aud: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                iss: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                jti: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            "400": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                error: {
+                                                    type: string;
+                                                };
+                                                error_description: {
+                                                    type: string;
+                                                };
+                                                error_uri: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("better-auth").JWTPayload>;
+            oauth2Revoke: import("better-call").StrictEndpoint<"/oauth2/revoke", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    client_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_secret: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    token: import("better-auth").ZodString;
+                    token_type_hint: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        refresh_token: "refresh_token";
+                        access_token: "access_token";
+                    }>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    allowedMediaTypes: string[];
+                    openapi: {
+                        description: string;
+                        requestBody: {
+                            required: boolean;
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            client_id: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            client_secret: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            token: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            token_type_hint: {
+                                                type: string;
+                                                enum: string[];
+                                                description: string;
+                                            };
+                                        };
+                                        required: string[];
+                                    };
+                                };
+                            };
+                        };
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            description: string;
+                                        };
+                                    };
+                                };
+                            };
+                            "400": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                error: {
+                                                    type: string;
+                                                };
+                                                error_description: {
+                                                    type: string;
+                                                };
+                                                error_uri: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, null | undefined>;
+            oauth2UserInfo: import("better-call").StrictEndpoint<"/oauth2/userinfo", {
+                method: ("GET" | "POST")[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        security: ({
+                            bearerAuth: never[];
+                            OAuth2?: undefined;
+                        } | {
+                            OAuth2: string[];
+                            bearerAuth?: undefined;
+                        })[];
+                        parameters: {
+                            name: string;
+                            in: "header";
+                            required: false;
+                            schema: {
+                                type: "string";
+                            };
+                            description: string;
+                        }[];
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                sub: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                email: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                name: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                picture: {
+                                                    type: string;
+                                                    format: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                given_name: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                family_name: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                email_verified: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            "401": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                error: {
+                                                    type: string;
+                                                };
+                                                error_description: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            "403": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                error: {
+                                                    type: string;
+                                                };
+                                                error_description: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                email?: string | undefined;
+                email_verified?: boolean | undefined;
+                name?: string | undefined;
+                picture?: string | undefined;
+                given_name?: string | undefined;
+                family_name?: string | undefined;
+                sub: string;
+            }>;
+            oauth2EndSession: import("better-call").StrictEndpoint<"/oauth2/end-session", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    id_token_hint: import("better-auth").ZodString;
+                    client_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    post_logout_redirect_uri: import("better-auth").ZodOptional<import("better-auth").ZodURL>;
+                    state: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                redirect_uri: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                message: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                redirect: boolean;
+                url: string;
+            } | undefined>;
+            registerOAuthClient: import("better-call").StrictEndpoint<"/oauth2/register", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    redirect_uris: import("better-auth").ZodArray<import("better-auth").ZodURL>;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    logo_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    contacts: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    tos_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    policy_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    software_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    software_version: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    software_statement: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    post_logout_redirect_uris: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodURL>>;
+                    token_endpoint_auth_method: import("better-auth").ZodOptional<import("better-auth").ZodDefault<import("better-auth").ZodEnum<{
+                        none: "none";
+                        client_secret_basic: "client_secret_basic";
+                        client_secret_post: "client_secret_post";
+                    }>>>;
+                    grant_types: import("better-auth").ZodOptional<import("better-auth").ZodDefault<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                        authorization_code: "authorization_code";
+                        client_credentials: "client_credentials";
+                        refresh_token: "refresh_token";
+                    }>>>>;
+                    response_types: import("better-auth").ZodOptional<import("better-auth").ZodDefault<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                        code: "code";
+                    }>>>>;
+                    type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        web: "web";
+                        native: "native";
+                        "user-agent-based": "user-agent-based";
+                    }>>;
+                    subject_type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        public: "public";
+                        pairwise: "pairwise";
+                    }>>;
+                    skip_consent: import("better-auth").ZodOptional<import("better-auth").ZodNever>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                client_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_secret: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_secret_expires_at: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                scope: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_id_issued_at: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_name: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                logo_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                contacts: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                tos_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                policy_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                software_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                software_version: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                software_statement: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                redirect_uris: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        format: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                post_logout_redirect_uris: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        format: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                token_endpoint_auth_method: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                grant_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    description: string;
+                                                };
+                                                response_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    description: string;
+                                                };
+                                                public: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                type: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                disabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            adminCreateOAuthClient: import("better-call").StrictEndpoint<"/admin/oauth2/create-client", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    redirect_uris: import("better-auth").ZodArray<import("better-auth").ZodURL>;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    logo_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    contacts: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    tos_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    policy_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    software_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    software_version: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    software_statement: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    post_logout_redirect_uris: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodURL>>;
+                    token_endpoint_auth_method: import("better-auth").ZodOptional<import("better-auth").ZodDefault<import("better-auth").ZodEnum<{
+                        none: "none";
+                        client_secret_basic: "client_secret_basic";
+                        client_secret_post: "client_secret_post";
+                    }>>>;
+                    grant_types: import("better-auth").ZodOptional<import("better-auth").ZodDefault<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                        authorization_code: "authorization_code";
+                        client_credentials: "client_credentials";
+                        refresh_token: "refresh_token";
+                    }>>>>;
+                    response_types: import("better-auth").ZodOptional<import("better-auth").ZodDefault<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                        code: "code";
+                    }>>>>;
+                    type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        web: "web";
+                        native: "native";
+                        "user-agent-based": "user-agent-based";
+                    }>>;
+                    client_secret_expires_at: import("better-auth").ZodDefault<import("better-auth").ZodOptional<import("better-auth").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodNumber]>>>;
+                    skip_consent: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    enable_end_session: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    require_pkce: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    subject_type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        public: "public";
+                        pairwise: "pairwise";
+                    }>>;
+                    metadata: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    SERVER_ONLY: true;
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                client_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_secret: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_secret_expires_at: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                scope: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_id_issued_at: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_name: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                logo_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                contacts: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                tos_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                policy_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                software_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                software_version: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                software_statement: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                redirect_uris: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        format: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                token_endpoint_auth_method: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                grant_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    description: string;
+                                                };
+                                                response_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    description: string;
+                                                };
+                                                public: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                type: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                disabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                require_pkce: {
+                                                    type: string;
+                                                    description: string;
+                                                    default: boolean;
+                                                };
+                                                metadata: {
+                                                    type: string;
+                                                    additionalProperties: boolean;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            createOAuthClient: import("better-call").StrictEndpoint<"/oauth2/create-client", {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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<{
+                    redirect_uris: import("better-auth").ZodArray<import("better-auth").ZodURL>;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    logo_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    contacts: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    tos_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    policy_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    software_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    software_version: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    software_statement: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    post_logout_redirect_uris: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodURL>>;
+                    token_endpoint_auth_method: import("better-auth").ZodOptional<import("better-auth").ZodDefault<import("better-auth").ZodEnum<{
+                        none: "none";
+                        client_secret_basic: "client_secret_basic";
+                        client_secret_post: "client_secret_post";
+                    }>>>;
+                    grant_types: import("better-auth").ZodOptional<import("better-auth").ZodDefault<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                        authorization_code: "authorization_code";
+                        client_credentials: "client_credentials";
+                        refresh_token: "refresh_token";
+                    }>>>>;
+                    response_types: import("better-auth").ZodOptional<import("better-auth").ZodDefault<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                        code: "code";
+                    }>>>>;
+                    type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        web: "web";
+                        native: "native";
+                        "user-agent-based": "user-agent-based";
+                    }>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                client_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_secret: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_secret_expires_at: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                scope: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_id_issued_at: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_name: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                client_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                logo_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                contacts: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                tos_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                policy_uri: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                software_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                software_version: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                software_statement: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                redirect_uris: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        format: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                token_endpoint_auth_method: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                grant_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    description: string;
+                                                };
+                                                response_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    description: string;
+                                                };
+                                                public: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                type: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                disabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                metadata: {
+                                                    type: string;
+                                                    additionalProperties: boolean;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            getOAuthClient: import("better-call").StrictEndpoint<"/oauth2/get-client", {
+                method: "GET";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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").ZodObject<{
+                    client_id: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            getOAuthClientPublic: import("better-call").StrictEndpoint<"/oauth2/public-client", {
+                method: "GET";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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").ZodObject<{
+                    client_id: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            getOAuthClientPublicPrelogin: import("better-call").StrictEndpoint<"/oauth2/public-client-prelogin", {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>)[];
+                body: import("better-auth").ZodObject<{
+                    client_id: import("better-auth").ZodString;
+                    oauth_query: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            getOAuthClients: import("better-call").StrictEndpoint<"/oauth2/get-clients", {
+                method: "GET";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient[] | null>;
+            adminUpdateOAuthClient: import("better-call").StrictEndpoint<"/admin/oauth2/update-client", {
+                method: "PATCH";
+                body: import("better-auth").ZodObject<{
+                    client_id: import("better-auth").ZodString;
+                    update: import("better-auth").ZodObject<{
+                        redirect_uris: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodURL>>;
+                        scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        client_name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        client_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        logo_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        contacts: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                        tos_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        policy_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        software_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        software_version: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        software_statement: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        post_logout_redirect_uris: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodURL>>;
+                        grant_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                            authorization_code: "authorization_code";
+                            client_credentials: "client_credentials";
+                            refresh_token: "refresh_token";
+                        }>>>;
+                        response_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                            code: "code";
+                        }>>>;
+                        type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                            web: "web";
+                            native: "native";
+                            "user-agent-based": "user-agent-based";
+                        }>>;
+                        client_secret_expires_at: import("better-auth").ZodOptional<import("better-auth").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodNumber]>>;
+                        skip_consent: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                        enable_end_session: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                        metadata: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>>;
+                    }, import("zod/v4/core").$strip>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    SERVER_ONLY: true;
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            updateOAuthClient: import("better-call").StrictEndpoint<"/oauth2/update-client", {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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<{
+                    client_id: import("better-auth").ZodString;
+                    update: import("better-auth").ZodObject<{
+                        redirect_uris: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodURL>>;
+                        scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        client_name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        client_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        logo_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        contacts: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                        tos_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        policy_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        software_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        software_version: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        software_statement: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                        post_logout_redirect_uris: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodURL>>;
+                        grant_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                            authorization_code: "authorization_code";
+                            client_credentials: "client_credentials";
+                            refresh_token: "refresh_token";
+                        }>>>;
+                        response_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                            code: "code";
+                        }>>>;
+                        type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                            web: "web";
+                            native: "native";
+                            "user-agent-based": "user-agent-based";
+                        }>>;
+                    }, import("zod/v4/core").$strip>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            rotateClientSecret: import("better-call").StrictEndpoint<"/oauth2/client/rotate-secret", {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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<{
+                    client_id: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            deleteOAuthClient: import("better-call").StrictEndpoint<"/oauth2/delete-client", {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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<{
+                    client_id: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, void>;
+            getOAuthConsent: import("better-call").StrictEndpoint<"/oauth2/get-consent", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    id: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthConsent<import("@better-auth/oauth-provider").Scope[]>>;
+            getOAuthConsents: import("better-call").StrictEndpoint<"/oauth2/get-consents", {
+                method: "GET";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthConsent<import("@better-auth/oauth-provider").Scope[]>[]>;
+            updateOAuthConsent: import("better-call").StrictEndpoint<"/oauth2/update-consent", {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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<{
+                    id: import("better-auth").ZodString;
+                    update: import("better-auth").ZodObject<{
+                        scopes: import("better-auth").ZodArray<import("better-auth").ZodString>;
+                    }, import("zod/v4/core").$strip>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthConsent<import("@better-auth/oauth-provider").Scope[]> | null>;
+            deleteOAuthConsent: import("better-call").StrictEndpoint<"/oauth2/delete-consent", {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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<{
+                    id: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, void>;
+        };
+        schema: {
+            oauthClient: {
+                modelName: string;
+                fields: {
+                    clientId: {
+                        type: "string";
+                        unique: true;
+                        required: true;
+                    };
+                    clientSecret: {
+                        type: "string";
+                        required: false;
+                    };
+                    disabled: {
+                        type: "boolean";
+                        defaultValue: false;
+                        required: false;
+                    };
+                    skipConsent: {
+                        type: "boolean";
+                        required: false;
+                    };
+                    enableEndSession: {
+                        type: "boolean";
+                        required: false;
+                    };
+                    subjectType: {
+                        type: "string";
+                        required: false;
+                    };
+                    scopes: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    userId: {
+                        type: "string";
+                        required: false;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    updatedAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    name: {
+                        type: "string";
+                        required: false;
+                    };
+                    uri: {
+                        type: "string";
+                        required: false;
+                    };
+                    icon: {
+                        type: "string";
+                        required: false;
+                    };
+                    contacts: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    tos: {
+                        type: "string";
+                        required: false;
+                    };
+                    policy: {
+                        type: "string";
+                        required: false;
+                    };
+                    softwareId: {
+                        type: "string";
+                        required: false;
+                    };
+                    softwareVersion: {
+                        type: "string";
+                        required: false;
+                    };
+                    softwareStatement: {
+                        type: "string";
+                        required: false;
+                    };
+                    redirectUris: {
+                        type: "string[]";
+                        required: true;
+                    };
+                    postLogoutRedirectUris: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    tokenEndpointAuthMethod: {
+                        type: "string";
+                        required: false;
+                    };
+                    grantTypes: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    responseTypes: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    public: {
+                        type: "boolean";
+                        required: false;
+                    };
+                    type: {
+                        type: "string";
+                        required: false;
+                    };
+                    requirePKCE: {
+                        type: "boolean";
+                        required: false;
+                    };
+                    referenceId: {
+                        type: "string";
+                        required: false;
+                    };
+                    metadata: {
+                        type: "json";
+                        required: false;
+                    };
+                };
+            };
+            oauthRefreshToken: {
+                fields: {
+                    token: {
+                        type: "string";
+                        required: true;
+                        unique: true;
+                    };
+                    clientId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    sessionId: {
+                        type: "string";
+                        required: false;
+                        references: {
+                            model: string;
+                            field: string;
+                            onDelete: "set null";
+                        };
+                        index: true;
+                    };
+                    userId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    referenceId: {
+                        type: "string";
+                        required: false;
+                    };
+                    expiresAt: {
+                        type: "date";
+                    };
+                    createdAt: {
+                        type: "date";
+                    };
+                    revoked: {
+                        type: "date";
+                        required: false;
+                    };
+                    authTime: {
+                        type: "date";
+                        required: false;
+                    };
+                    scopes: {
+                        type: "string[]";
+                        required: true;
+                    };
+                };
+            };
+            oauthAccessToken: {
+                modelName: string;
+                fields: {
+                    token: {
+                        type: "string";
+                        unique: true;
+                    };
+                    clientId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    sessionId: {
+                        type: "string";
+                        required: false;
+                        references: {
+                            model: string;
+                            field: string;
+                            onDelete: "set null";
+                        };
+                        index: true;
+                    };
+                    userId: {
+                        type: "string";
+                        required: false;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    referenceId: {
+                        type: "string";
+                        required: false;
+                    };
+                    refreshId: {
+                        type: "string";
+                        required: false;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    expiresAt: {
+                        type: "date";
+                    };
+                    createdAt: {
+                        type: "date";
+                    };
+                    scopes: {
+                        type: "string[]";
+                        required: true;
+                    };
+                };
+            };
+            oauthConsent: {
+                modelName: string;
+                fields: {
+                    clientId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    userId: {
+                        type: "string";
+                        required: false;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    referenceId: {
+                        type: "string";
+                        required: false;
+                    };
+                    scopes: {
+                        type: "string[]";
+                        required: true;
+                    };
+                    createdAt: {
+                        type: "date";
+                    };
+                    updatedAt: {
+                        type: "date";
+                    };
+                };
+            };
+        };
+        rateLimit: ({
+            pathMatcher: (path: string) => path is "/oauth2/token";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher: (path: string) => path is "/oauth2/authorize";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher: (path: string) => path is "/oauth2/introspect";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher: (path: string) => path is "/oauth2/revoke";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher: (path: string) => path is "/oauth2/register";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher: (path: string) => path is "/oauth2/userinfo";
+            window: number;
+            max: number;
+        })[];
+    }];
+    socialProviders: {
+        google: {
+            clientId: string;
+            clientSecret: string;
+            disableSignUp: true;
+        };
+    } | {
+        google?: never;
+    };
+    account: {
+        accountLinking?: {
+            trustedProviders: "antasphere"[];
+            requireLocalEmailVerified: true;
+        };
+        encryptOAuthTokens: true;
+    };
+    baseURL: string;
+    basePath: string;
+    secret: string;
+}>;
+//# sourceMappingURL=better-auth.d.ts.map