@tempoxyz/id 0.0.0-pr-187.sha-eed04d3

package/dist/internal/Auth.d.ts

@@ -0,0 +1,4058 @@
+/**
+ * Builds the Better Auth options that every Tempo ID app shares, and declares the sign-in refusals.
+ * Callers pass the database, secret, and origin, so the options read no environment of their own.
+ * @module
+ */
+import type { betterAuth, BetterAuthOptions } from 'better-auth';
+import type * as BetterCall from 'better-call';
+import { drizzleAdapter } from 'better-auth/adapters/drizzle';
+import * as Apps from './Apps.js';
+import * as ErrorResponse from './ErrorResponse.js';
+declare const AuthorizationExpiredError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            error: "invalid_request";
+            reason: "authorization_expired";
+        };
+    };
+    readonly reason: "authorization_expired";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/**
+ * The app's authorization request that a sign-in or the approval page continues, its signed
+ * `oauth_query`, is forged or expired. The sign-in did not run, so the code stays unspent.
+ */
+export declare class AuthorizationExpiredError extends AuthorizationExpiredError_base {
+    readonly name = "Auth.AuthorizationExpiredError";
+    constructor();
+}
+declare const InvalidCodeError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            error: "invalid_grant";
+            reason: "invalid_code";
+        };
+    };
+    readonly reason: "invalid_code";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The emailed code is wrong or expired. The refusal never reveals whether the account exists. */
+export declare class InvalidCodeError extends InvalidCodeError_base {
+    readonly name = "Auth.InvalidCodeError";
+    constructor();
+}
+declare const SessionChangedError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            error: "invalid_request";
+            reason: "session_changed";
+        };
+    };
+    readonly reason: "session_changed";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/**
+ * The signed-in session differs from the one that the approval page showed, such as after a sign-in
+ * to another account in another tab. The approval page stored no consent.
+ */
+export declare class SessionChangedError extends SessionChangedError_base {
+    readonly name = "Auth.SessionChangedError";
+    constructor();
+}
+declare const SessionRequiredError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            error: "login_required";
+            reason: "session_required";
+        };
+    };
+    readonly reason: "session_required";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The request needs a signed-in session, and has none. */
+export declare class SessionRequiredError extends SessionRequiredError_base {
+    readonly name = "Auth.SessionRequiredError";
+    constructor();
+}
+/**
+ * A request validation issue from the device plugin's types. Declarations name it through this alias,
+ * since TypeScript cannot reach it from `better-call`'s exports alone.
+ */
+export type Issue = BetterCall.StandardSchemaV1.Issue;
+/** A Better Auth instance with Tempo ID's options, which each request creates. */
+export type Instance = ReturnType<typeof betterAuth<ReturnType<typeof options>>>;
+/** The session cookie, which every app on the same site shares. */
+export declare const sessionCookie = "tempo-id-session";
+/** Returns the Better Auth options for `options`. */
+export declare function options(options: options.Options): {
+    account: {
+        updateAccountOnSignIn: false;
+    };
+    advanced: {
+        backgroundTasks: {
+            handler: (promise: Promise<unknown>) => void;
+        };
+        cookies: {
+            session_token: {
+                name: string;
+            };
+        };
+        database: {
+            generateId: (id: {
+                model: import("better-auth").ModelNames;
+                size?: number | undefined;
+            }) => string;
+        };
+        ipAddress: {
+            ipAddressHeaders: string[];
+        };
+    };
+    basePath: string;
+    baseURL: string;
+    database: (options: BetterAuthOptions) => import("better-auth").DBAdapter<BetterAuthOptions>;
+    databaseHooks: {
+        account: {
+            create: {
+                before: () => Promise<{
+                    data: {
+                        accessToken: null;
+                        accessTokenExpiresAt: null;
+                        idToken: null;
+                        refreshToken: null;
+                        refreshTokenExpiresAt: null;
+                    };
+                }>;
+            };
+        };
+        user: {
+            create: {
+                before: (user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, unknown>) => Promise<boolean>;
+            };
+        };
+    };
+    onAPIError: {
+        errorURL: string;
+    };
+    plugins: [{
+        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: BetterCall.StrictEndpoint<"/email-otp/send-verification-otp", {
+                method: "POST";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.MiddlewareOptions>) => Promise<void>>[];
+                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: BetterCall.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: BetterCall.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: BetterCall.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: BetterCall.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: BetterCall.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: BetterCall.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: BetterCall.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: BetterCall.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: BetterCall.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: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.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: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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/email-otp").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">;
+        };
+    }, {
+        endpoints: {
+            signInPasskey: BetterCall.StrictEndpoint<string, {
+                body: import("better-auth").ZodObject<{
+                    oauth_query: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    userId: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                method: "POST";
+            }, {
+                user: {
+                    email: string;
+                    id: string;
+                };
+            }>;
+        };
+        id: "tempo-id-passkey";
+    }, ...({
+        id: "jwt";
+        version: string;
+        options: NoInfer<{
+            adapter: {
+                getJwks: (ctx: import("better-auth").GenericEndpointContext) => Promise<import("better-auth/plugins").Jwk[]>;
+            };
+            jwks: {
+                gracePeriod: number;
+                jwksPath: string;
+                keyPairConfig: {
+                    alg: 'RS256';
+                    modulusLength: number;
+                };
+            };
+            jwt: {
+                issuer: string;
+            };
+        }>;
+        init(ctx: import("better-auth").AuthContext): {
+            context: {
+                sessionConfig: {
+                    cookieCacheSigner: import("better-auth").CookieCacheSigner;
+                    updateAge: number;
+                    expiresIn: number;
+                    freshAge: number;
+                    cookieRefreshCache: false | {
+                        enabled: true;
+                        updateAge: number;
+                    };
+                };
+            };
+        } | undefined;
+        endpoints: {
+            getJwks: BetterCall.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: BetterCall.StrictEndpoint<"/token", {
+                method: "GET";
+                requireHeaders: true;
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.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: BetterCall.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: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.MiddlewareOptions>) => Promise<void>>;
+            }[];
+        };
+        schema: {
+            jwks: {
+                fields: {
+                    publicKey: {
+                        type: "string";
+                        required: true;
+                    };
+                    privateKey: {
+                        type: "string";
+                        required: true;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                    };
+                    expiresAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    alg: {
+                        type: "string";
+                        required: false;
+                    };
+                    crv: {
+                        type: "string";
+                        required: false;
+                    };
+                };
+            };
+        };
+    } | {
+        id: "oauth-provider";
+        version: string;
+        options: NoInfer<{
+            allowDynamicClientRegistration: false;
+            consentPage: string;
+            customIdTokenClaims: (info: {
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, unknown>;
+                scopes: import("@better-auth/oauth-provider").Scope[];
+                metadata?: Record<string, any>;
+            }) => {
+                email: string;
+                email_verified: boolean;
+            } | {
+                email?: never;
+                email_verified?: never;
+            };
+            enforcePerClientResources: false;
+            loginPage: string;
+            postLogin?: {
+                consentReferenceId: () => undefined;
+                page: string;
+                shouldRedirect: (context: {
+                    headers: Headers;
+                    session: {
+                        id: string;
+                    };
+                    user: {
+                        id: string;
+                    };
+                }) => Promise<boolean>;
+            };
+            customTokenResponseFields?: (info: {
+                grantType: string;
+                user?: {
+                    id: string;
+                } | null | undefined;
+                verificationValue?: {
+                    query: {
+                        client_id: string;
+                        code_challenge?: string | undefined;
+                        key_authorization?: unknown;
+                    };
+                };
+            }) => Promise<{
+                account?: never;
+                key_authorization?: never;
+            } | {
+                account: `0x${string}`;
+                key_authorization: import("ox/tempo/KeyAuthorization").Rpc;
+            }>;
+            resources: {
+                accessTokenTtl: number;
+                identifier: string;
+                name: string;
+            }[];
+            scopes: ("email" | "offline_access" | "openid" | "profile")[];
+            storeClientSecret: {
+                hash: typeof Apps.hashSecret;
+            };
+        }>;
+        onRequest: (request: Request, ctx: import("better-auth").AuthContext) => Promise<{
+            response: Response;
+        } | {
+            request: Request;
+        } | void>;
+        init: (ctx: import("better-auth").AuthContext) => Promise<{
+            options: {
+                databaseHooks: {
+                    session: {
+                        delete: {
+                            before(session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            } & Record<string, unknown>, hookCtx: import("better-auth").GenericEndpointContext | null): Promise<void>;
+                            after(session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            } & Record<string, unknown>, hookCtx: import("better-auth").GenericEndpointContext | null): Promise<void>;
+                        };
+                    };
+                };
+            };
+        }>;
+        hooks: {
+            before: {
+                matcher(ctx: import("better-auth").HookEndpointContext): any;
+                handler: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.MiddlewareOptions>) => Promise<void>>;
+            }[];
+            after: {
+                matcher(ctx: import("better-auth").HookEndpointContext): boolean;
+                handler: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.MiddlewareOptions>) => Promise<{
+                    redirect: true;
+                    url: string;
+                } | undefined>>;
+            }[];
+        };
+        endpoints: {
+            getOAuthServerConfig: BetterCall.StrictEndpoint<"/.well-known/oauth-authorization-server", {
+                method: "GET";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").AuthServerMetadata>;
+            getOpenIdConfig: BetterCall.StrictEndpoint<"/.well-known/openid-configuration", {
+                method: "GET";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, {
+                jwks_uri?: string | undefined;
+                userinfo_endpoint: string;
+                acr_values_supported?: string[] | undefined;
+                subject_types_supported: ("public" | "pairwise")[];
+                claims_supported: string[];
+                claims_parameter_supported?: boolean | undefined;
+                end_session_endpoint: string;
+                request_parameter_supported?: boolean | undefined;
+                request_uri_parameter_supported?: boolean | undefined;
+                prompt_values_supported: import("@better-auth/oauth-provider").Prompt[];
+                issuer: string;
+                authorization_endpoint: string;
+                token_endpoint: string;
+                registration_endpoint?: string | undefined;
+                scopes_supported?: string[] | undefined;
+                response_types_supported: "code"[];
+                response_modes_supported: "query"[];
+                grant_types_supported: import("@better-auth/oauth-provider").GrantType[];
+                token_endpoint_auth_methods_supported?: import("@better-auth/oauth-provider").TokenEndpointAuthMethod[] | undefined;
+                token_endpoint_auth_signing_alg_values_supported?: import("better-auth").PrivateKeyJwtSigningAlgorithm[] | undefined;
+                service_documentation?: string | undefined;
+                ui_locales_supported?: string[] | undefined;
+                op_policy_uri?: string | undefined;
+                op_tos_uri?: string | undefined;
+                revocation_endpoint?: string | undefined;
+                revocation_endpoint_auth_methods_supported?: import("@better-auth/oauth-provider").TokenEndpointAuthMethod[] | undefined;
+                revocation_endpoint_auth_signing_alg_values_supported?: import("better-auth").PrivateKeyJwtSigningAlgorithm[] | undefined;
+                introspection_endpoint?: string | undefined;
+                introspection_endpoint_auth_methods_supported?: import("@better-auth/oauth-provider").TokenEndpointAuthMethod[] | undefined;
+                introspection_endpoint_auth_signing_alg_values_supported?: import("better-auth").PrivateKeyJwtSigningAlgorithm[] | undefined;
+                code_challenge_methods_supported: "S256"[];
+                authorization_response_iss_parameter_supported?: boolean | undefined;
+                client_id_metadata_document_supported?: boolean | undefined;
+                backchannel_logout_supported?: boolean | undefined;
+                backchannel_logout_session_supported?: boolean | undefined;
+                dpop_signing_alg_values_supported?: import("better-auth/plugins").JWSAlgorithms[] | undefined;
+                id_token_signing_alg_values_supported: import("better-auth/plugins").JWSAlgorithms[] | ["HS256"];
+            }>;
+            oauth2Authorize: BetterCall.StrictEndpoint<"/oauth2/authorize", {
+                method: ("GET" | "POST")[];
+                body: import("better-auth").ZodObject<{}, import("zod/v4/core").$loose>;
+                redirectOnError: import("@better-auth/oauth-provider").OAuthRedirectOnError<import("better-auth").GenericEndpointContext, {
+                    redirect: true;
+                    url: string;
+                }>;
+                metadata: {
+                    allowedMediaTypes: string[];
+                    openapi: {
+                        description: string;
+                        parameters: ({
+                            name: string;
+                            in: "query";
+                            required: false;
+                            schema: {
+                                type: "string";
+                                format?: undefined;
+                                minimum?: undefined;
+                                items?: undefined;
+                            };
+                            description: string;
+                        } | {
+                            name: string;
+                            in: "query";
+                            required: true;
+                            schema: {
+                                type: "string";
+                                format?: undefined;
+                                minimum?: undefined;
+                                items?: undefined;
+                            };
+                            description: string;
+                        } | {
+                            name: string;
+                            in: "query";
+                            required: false;
+                            schema: {
+                                type: "string";
+                                format: string;
+                                minimum?: undefined;
+                                items?: undefined;
+                            };
+                            description: string;
+                        } | {
+                            name: string;
+                            in: "query";
+                            required: false;
+                            schema: {
+                                type: "integer";
+                                minimum: number;
+                                format?: undefined;
+                                items?: undefined;
+                            };
+                            description: string;
+                        } | {
+                            name: string;
+                            in: "query";
+                            required: false;
+                            schema: {
+                                type: "array";
+                                items: {
+                                    type: "string";
+                                };
+                                format?: undefined;
+                                minimum?: undefined;
+                            };
+                            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: true;
+                url: string;
+            }>;
+            oauth2Consent: BetterCall.StrictEndpoint<"/oauth2/consent", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    accept: import("better-auth").ZodBoolean;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    claims: import("better-auth").ZodOptional<import("better-auth").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>]>>;
+                    oauth_query: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: true;
+                url: string;
+            } | {
+                redirect: boolean;
+                url: string;
+            }>;
+            oauth2Continue: BetterCall.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: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: true;
+                url: string;
+            }>;
+            oauth2Token: BetterCall.StrictEndpoint<"/oauth2/token", {
+                method: "POST";
+                cloneRequest: true;
+                body: import("better-auth").ZodObject<{
+                    grant_type: import("better-auth").ZodString;
+                    client_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_secret: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_assertion: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_assertion_type: 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").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>]>>;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$loose>;
+                errorCodesByField: {
+                    grant_type: {
+                        missing: "invalid_request";
+                        invalid: "unsupported_grant_type";
+                    };
+                    resource: {
+                        invalid: "invalid_target";
+                    };
+                };
+                metadata: {
+                    noStore: boolean;
+                    allowedMediaTypes: string[];
+                    openapi: {
+                        description: string;
+                        parameters: {
+                            name: string;
+                            in: "header";
+                            required: false;
+                            schema: {
+                                type: "string";
+                            };
+                            description: string;
+                        }[];
+                        requestBody: {
+                            required: boolean;
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            grant_type: {
+                                                type: 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: {
+                                                oneOf: ({
+                                                    type: string;
+                                                    description: string;
+                                                    items?: undefined;
+                                                } | {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: 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[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                expires_in: number;
+                access_token: string;
+                expires_at: number;
+                token_type: import("@better-auth/oauth-provider").TokenType;
+                refresh_token: string | undefined;
+                scope: string;
+                id_token: string | undefined;
+            }>;
+            oauth2Introspect: BetterCall.StrictEndpoint<"/oauth2/introspect", {
+                method: "POST";
+                cloneRequest: true;
+                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>;
+                    client_assertion: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_assertion_type: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    token: import("better-auth").ZodString;
+                    token_type_hint: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    noStore: boolean;
+                    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;
+                                                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: BetterCall.StrictEndpoint<"/oauth2/revoke", {
+                method: "POST";
+                cloneRequest: true;
+                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>;
+                    client_assertion: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_assertion_type: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    token: import("better-auth").ZodString;
+                    token_type_hint: 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: {
+                                            client_id: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            client_secret: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            token: {
+                                                type: string;
+                                                description: string;
+                                            };
+                                            token_type_hint: {
+                                                type: 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: BetterCall.StrictEndpoint<"/oauth2/userinfo", {
+                method: ("GET" | "POST")[];
+                body: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
+                    access_token: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$loose>>;
+                metadata: {
+                    noStore: boolean;
+                    allowedMediaTypes: string[];
+                    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[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                sub: unknown;
+            }>;
+            oauth2EndSession: BetterCall.StrictEndpoint<"/oauth2/end-session", {
+                method: ("GET" | "POST")[];
+                body: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
+                    id_token_hint: import("better-auth").ZodOptional<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>>;
+                query: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
+                    id_token_hint: import("better-auth").ZodOptional<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: {
+                    noStore: boolean;
+                    allowedMediaTypes: string[];
+                    $Infer: {
+                        body: {
+                            id_token_hint?: string;
+                            client_id?: string;
+                            post_logout_redirect_uri?: string;
+                            state?: string;
+                        } | {
+                            query: {
+                                id_token_hint?: string;
+                                client_id?: string;
+                                post_logout_redirect_uri?: string;
+                                state?: string;
+                            };
+                        };
+                        query: {
+                            id_token_hint?: string;
+                            client_id?: string;
+                            post_logout_redirect_uri?: string;
+                            state?: string;
+                        };
+                    };
+                    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;
+                                                };
+                                            };
+                                        };
+                                    };
+                                    "text/html": {
+                                        schema: {
+                                            type: "string";
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, Response | {
+                redirect: true;
+                url: string;
+            } | null>;
+            oauth2EndSessionConfirmation: BetterCall.StrictEndpoint<"/oauth2/end-session/confirm", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    action: import("better-auth").ZodLiteral<"confirm">;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    noStore: boolean;
+                    allowedMediaTypes: string[];
+                    scope: "http";
+                };
+            }, Response | {
+                redirect: true;
+                url: string;
+            } | null>;
+            registerOAuthClient: BetterCall.StrictEndpoint<"/oauth2/register", {
+                method: "POST";
+                body: 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>>;
+                    backchannel_logout_uri: import("better-auth").ZodOptional<import("better-auth").ZodURL>;
+                    backchannel_logout_session_required: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    token_endpoint_auth_method: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    jwks: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
+                        keys: import("better-auth").ZodArray<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>>;
+                    }, import("zod/v4/core").$strip>>;
+                    jwks_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    grant_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    response_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                        code: "code";
+                    }>>>;
+                    application_type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        web: "web";
+                        native: "native";
+                    }>>;
+                    subject_type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        public: "public";
+                        pairwise: "pairwise";
+                    }>>;
+                    dpop_bound_access_tokens: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    resources: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    skip_consent: import("better-auth").ZodOptional<import("better-auth").ZodNever>;
+                }, import("zod/v4/core").$strip>;
+                errorCodesByField: {
+                    redirect_uris: "invalid_redirect_uri";
+                    post_logout_redirect_uris: "invalid_redirect_uri";
+                    software_statement: "invalid_software_statement";
+                    resources: "invalid_target";
+                };
+                defaultError: "invalid_client_metadata";
+                metadata: {
+                    noStore: boolean;
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "201": {
+                                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;
+                                                };
+                                                backchannel_logout_uri: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                backchannel_logout_session_required: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                token_endpoint_auth_method: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                grant_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                response_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    description: string;
+                                                };
+                                                application_type: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                resources: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        format: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                disabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClientRegistrationResponse>;
+            adminCreateOAuthClient: BetterCall.StrictEndpoint<"/admin/oauth2/create-client", {
+                method: "POST";
+                body: 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>>;
+                    backchannel_logout_uri: import("better-auth").ZodOptional<import("better-auth").ZodURL>;
+                    backchannel_logout_session_required: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    token_endpoint_auth_method: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    application_type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        web: "web";
+                        native: "native";
+                    }>>;
+                    jwks: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
+                        keys: import("better-auth").ZodArray<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>>;
+                    }, import("zod/v4/core").$strip>>;
+                    jwks_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    grant_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    client_credentials_scopes: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    resources: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    response_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                        code: "code";
+                    }>>>;
+                    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>;
+                    dpop_bound_access_tokens: 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: {
+                    noStore: boolean;
+                    SERVER_ONLY: true;
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "201": {
+                                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;
+                                                };
+                                                client_credentials_scopes: {
+                                                    type: string;
+                                                    items: {
+                                                        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;
+                                                };
+                                                grant_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                response_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    description: string;
+                                                };
+                                                application_type: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                resources: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        format: string;
+                                                    };
+                                                    description: 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").OAuthClientAdministrativeResponse>;
+            createOAuthClient: BetterCall.StrictEndpoint<"/oauth2/create-client", {
+                method: "POST";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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").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>>;
+                    backchannel_logout_uri: import("better-auth").ZodOptional<import("better-auth").ZodURL>;
+                    backchannel_logout_session_required: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    token_endpoint_auth_method: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    application_type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                        web: "web";
+                        native: "native";
+                    }>>;
+                    jwks: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
+                        keys: import("better-auth").ZodArray<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>>;
+                    }, import("zod/v4/core").$strip>>;
+                    jwks_uri: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    grant_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    response_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                        code: "code";
+                    }>>>;
+                    dpop_bound_access_tokens: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    noStore: boolean;
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "201": {
+                                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;
+                                                };
+                                                grant_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                response_types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    description: string;
+                                                };
+                                                application_type: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: string[];
+                                                };
+                                                resources: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        format: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                                disabled: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                metadata: {
+                                                    type: string;
+                                                    additionalProperties: boolean;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClientRegistrationResponse>;
+            getOAuthClient: BetterCall.StrictEndpoint<"/oauth2/get-client", {
+                method: "GET";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.StrictEndpoint<"/oauth2/public-client", {
+                method: "GET";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.StrictEndpoint<"/oauth2/public-client-prelogin", {
+                method: "POST";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.StrictEndpoint<"/oauth2/get-clients", {
+                method: "GET";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.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>>;
+                        backchannel_logout_uri: import("better-auth").ZodOptional<import("better-auth").ZodURL>;
+                        backchannel_logout_session_required: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                        application_type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                            web: "web";
+                            native: "native";
+                        }>>;
+                        grant_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                        client_credentials_scopes: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                        response_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                            code: "code";
+                        }>>>;
+                        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>;
+                        disabled: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                        dpop_bound_access_tokens: 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").OAuthClientAdministrativeResponse>;
+            updateOAuthClient: BetterCall.StrictEndpoint<"/oauth2/update-client", {
+                method: "POST";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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>>;
+                        backchannel_logout_uri: import("better-auth").ZodOptional<import("better-auth").ZodURL>;
+                        backchannel_logout_session_required: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                        application_type: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                            web: "web";
+                            native: "native";
+                        }>>;
+                        grant_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                        response_types: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodEnum<{
+                            code: "code";
+                        }>>>;
+                    }, import("zod/v4/core").$strip>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClientRegistrationResponse>;
+            rotateClientSecret: BetterCall.StrictEndpoint<"/oauth2/client/rotate-secret", {
+                method: "POST";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: {
+                    noStore: boolean;
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            deleteOAuthClient: BetterCall.StrictEndpoint<"/oauth2/delete-client", {
+                method: "POST";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.StrictEndpoint<"/oauth2/get-consent", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    id: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.StrictEndpoint<"/oauth2/get-consents", {
+                method: "GET";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.StrictEndpoint<"/oauth2/update-consent", {
+                method: "POST";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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: BetterCall.StrictEndpoint<"/oauth2/delete-consent", {
+                method: "POST";
+                use: BetterCall.Middleware<BetterCall.MiddlewareOptions, (inputContext: BetterCall.MiddlewareInputContext<BetterCall.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>;
+            adminCreateOAuthResource: BetterCall.StrictEndpoint<"/admin/oauth2/resources", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    identifier: import("better-auth").ZodNonOptional<import("better-auth").ZodOptional<import("better-auth").ZodString>>;
+                    name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    accessTokenTtl: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodNumber>>;
+                    refreshTokenTtl: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodNumber>>;
+                    signingAlgorithm: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodEnum<{
+                        RS256: "RS256";
+                        PS256: "PS256";
+                        ES256: "ES256";
+                        ES512: "ES512";
+                        EdDSA: "EdDSA";
+                    }>>>;
+                    signingKeyId: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodString>>;
+                    allowedScopes: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodArray<import("better-auth").ZodString>>>;
+                    customClaims: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>>>;
+                    dpopBoundAccessTokensRequired: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    disabled: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    metadata: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").OAuthResource>;
+            adminListOAuthResources: BetterCall.StrictEndpoint<"/admin/oauth2/resources", {
+                method: "GET";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").OAuthResource[]>;
+            adminGetOAuthResource: BetterCall.StrictEndpoint<"/admin/oauth2/resources/:identifier", {
+                method: "GET";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").OAuthResource>;
+            adminUpdateOAuthResource: BetterCall.StrictEndpoint<"/admin/oauth2/resources/:identifier", {
+                method: "PATCH";
+                body: import("better-auth").ZodObject<{
+                    identifier: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    accessTokenTtl: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodNumber>>;
+                    refreshTokenTtl: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodNumber>>;
+                    signingAlgorithm: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodEnum<{
+                        RS256: "RS256";
+                        PS256: "PS256";
+                        ES256: "ES256";
+                        ES512: "ES512";
+                        EdDSA: "EdDSA";
+                    }>>>;
+                    signingKeyId: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodString>>;
+                    allowedScopes: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodArray<import("better-auth").ZodString>>>;
+                    customClaims: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>>>;
+                    dpopBoundAccessTokensRequired: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    disabled: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    metadata: import("better-auth").ZodOptional<import("better-auth").ZodNullable<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodUnknown>>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").OAuthResource>;
+            adminDeleteOAuthResource: BetterCall.StrictEndpoint<"/admin/oauth2/resources/:identifier", {
+                method: "DELETE";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, {
+                deleted: boolean;
+            }>;
+            adminLinkClientResource: BetterCall.StrictEndpoint<"/admin/oauth2/resources/:identifier/clients/:client_id", {
+                method: "POST";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, {
+                linked: boolean;
+            }>;
+            adminUnlinkClientResource: BetterCall.StrictEndpoint<"/admin/oauth2/resources/:identifier/clients/:client_id", {
+                method: "DELETE";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, {
+                unlinked: boolean;
+            }>;
+        };
+        schema: {
+            oauthClient: {
+                modelName: string;
+                fields: {
+                    clientId: {
+                        type: "string";
+                        unique: true;
+                        required: true;
+                    };
+                    clientSecret: {
+                        type: "string";
+                        required: false;
+                    };
+                    clientDiscoveryId: {
+                        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;
+                    };
+                    clientCredentialsScopes: {
+                        type: "string[]";
+                        required: false;
+                        defaultValue: never[];
+                    };
+                    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;
+                    };
+                    backchannelLogoutUri: {
+                        type: "string";
+                        required: false;
+                    };
+                    backchannelLogoutSessionRequired: {
+                        type: "boolean";
+                        required: false;
+                    };
+                    tokenEndpointAuthMethod: {
+                        type: "string";
+                        required: false;
+                    };
+                    applicationType: {
+                        type: "string";
+                        required: false;
+                    };
+                    jwks: {
+                        type: "string";
+                        required: false;
+                    };
+                    jwksUri: {
+                        type: "string";
+                        required: false;
+                    };
+                    grantTypes: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    responseTypes: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    requirePKCE: {
+                        type: "boolean";
+                        required: false;
+                    };
+                    dpopBoundAccessTokens: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: false;
+                    };
+                    referenceId: {
+                        type: "string";
+                        required: false;
+                    };
+                    metadata: {
+                        type: "json";
+                        required: false;
+                    };
+                };
+            };
+            oauthResource: {
+                modelName: string;
+                fields: {
+                    identifier: {
+                        type: "string";
+                        required: true;
+                        unique: true;
+                    };
+                    name: {
+                        type: "string";
+                        required: true;
+                    };
+                    accessTokenTtl: {
+                        type: "number";
+                        required: false;
+                    };
+                    refreshTokenTtl: {
+                        type: "number";
+                        required: false;
+                    };
+                    signingAlgorithm: {
+                        type: "string";
+                        required: false;
+                    };
+                    signingKeyId: {
+                        type: "string";
+                        required: false;
+                    };
+                    allowedScopes: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    customClaims: {
+                        type: "json";
+                        required: false;
+                    };
+                    dpopBoundAccessTokensRequired: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: false;
+                    };
+                    disabled: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: false;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    updatedAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    policyVersion: {
+                        type: "number";
+                        required: false;
+                        defaultValue: number;
+                    };
+                    metadata: {
+                        type: "json";
+                        required: false;
+                    };
+                };
+            };
+            oauthClientResource: {
+                modelName: string;
+                fields: {
+                    clientId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: string;
+                            field: string;
+                            onDelete: "cascade";
+                        };
+                        index: true;
+                    };
+                    resourceId: {
+                        type: "string";
+                        required: true;
+                        references: {
+                            model: string;
+                            field: string;
+                            onDelete: "cascade";
+                        };
+                        index: true;
+                    };
+                    metadata: {
+                        type: "json";
+                        required: false;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: false;
+                    };
+                };
+                indexes: {
+                    fields: [string, string];
+                    unique: true;
+                }[];
+            };
+            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;
+                    };
+                    authorizationCodeId: {
+                        type: "string";
+                        required: false;
+                        index: true;
+                    };
+                    resources: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    requestedUserInfoClaims: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    expiresAt: {
+                        type: "date";
+                    };
+                    createdAt: {
+                        type: "date";
+                    };
+                    revoked: {
+                        type: "date";
+                        required: false;
+                    };
+                    rotatedAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    rotationReplayResponse: {
+                        type: "string";
+                        required: false;
+                    };
+                    rotationReplayExpiresAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    authTime: {
+                        type: "date";
+                        required: false;
+                    };
+                    confirmation: {
+                        type: "json";
+                        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;
+                    };
+                    authorizationCodeId: {
+                        type: "string";
+                        required: false;
+                        index: true;
+                    };
+                    resources: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    requestedUserInfoClaims: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    refreshId: {
+                        type: "string";
+                        required: false;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    expiresAt: {
+                        type: "date";
+                    };
+                    createdAt: {
+                        type: "date";
+                    };
+                    revoked: {
+                        type: "date";
+                        required: false;
+                    };
+                    confirmation: {
+                        type: "json";
+                        required: false;
+                    };
+                    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;
+                    };
+                    resources: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    requestedUserInfoClaims: {
+                        type: "string[]";
+                        required: false;
+                    };
+                    scopes: {
+                        type: "string[]";
+                        required: true;
+                    };
+                    createdAt: {
+                        type: "date";
+                    };
+                    updatedAt: {
+                        type: "date";
+                    };
+                };
+            };
+            oauthClientAssertion: {
+                modelName: string;
+                fields: {
+                    expiresAt: {
+                        type: "date";
+                        required: true;
+                    };
+                };
+            };
+        };
+        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;
+        })[];
+    })[], {
+        init(ctx: import("better-auth").AuthContext): void;
+        id: "device-authorization";
+        version: string;
+        schema: {
+            deviceCode: {
+                fields: {
+                    deviceCode: {
+                        type: "string";
+                        required: true;
+                    };
+                    userCode: {
+                        type: "string";
+                        required: true;
+                    };
+                    userId: {
+                        type: "string";
+                        required: false;
+                    };
+                    expiresAt: {
+                        type: "date";
+                        required: true;
+                    };
+                    status: {
+                        type: "string";
+                        required: true;
+                    };
+                    lastPolledAt: {
+                        type: "date";
+                        required: false;
+                    };
+                    pollingInterval: {
+                        type: "number";
+                        required: false;
+                    };
+                    clientId: {
+                        type: "string";
+                        required: false;
+                    };
+                    scope: {
+                        type: "string";
+                        required: false;
+                    };
+                };
+                indexes: {
+                    fields: [string];
+                    unique: true;
+                }[];
+            };
+        };
+        endpoints: {
+            deviceCode: BetterCall.StrictEndpoint<"/device/code", {
+                method: "POST";
+                cloneRequest: true;
+                body: import("better-auth").ZodObject<{
+                    client_id: import("better-auth").ZodString;
+                    user_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_secret: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_assertion: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_assertion_type: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    resource: import("better-auth").ZodOptional<import("better-auth").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>, import("better-auth").ZodLiteral<"">]>>;
+                }, import("zod/v4/core").$strip> | import("better-auth").ZodObject<{
+                    user_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    scope: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_id: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_secret: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_assertion: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    client_assertion_type: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    resource: import("better-auth").ZodOptional<import("better-auth").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>, import("better-auth").ZodLiteral<"">]>>;
+                }, import("zod/v4/core").$strip>;
+                error: import("better-auth").ZodObject<{
+                    error: import("better-auth").ZodEnum<{
+                        invalid_request: "invalid_request";
+                        invalid_client: "invalid_client";
+                        unauthorized_client: "unauthorized_client";
+                        invalid_scope: "invalid_scope";
+                        server_error: "server_error";
+                        invalid_target: "invalid_target";
+                    }>;
+                    error_description: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                onValidationError: ({ issues, message }: {
+                    message: string;
+                    issues: readonly BetterCall.StandardSchemaV1.Issue[];
+                }) => never;
+                metadata: {
+                    noStore: boolean;
+                    allowedMediaTypes: string[];
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                device_code: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user_code: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                verification_uri: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                verification_uri_complete: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                expires_in: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                interval: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            400: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                error: {
+                                                    type: string;
+                                                    enum: ["invalid_request", "invalid_client", "unauthorized_client", "invalid_scope", "invalid_target"];
+                                                };
+                                                error_description: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            500: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                error: {
+                                                    type: string;
+                                                    enum: string[];
+                                                };
+                                                error_description: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                device_code: string;
+                user_code: string;
+                verification_uri: string;
+                verification_uri_complete: string;
+                expires_in: number;
+                interval: number;
+            }>;
+            deviceToken: BetterCall.StrictEndpoint<"/device/token", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    grant_type: import("better-auth").ZodLiteral<"urn:ietf:params:oauth:grant-type:device_code">;
+                    device_code: import("better-auth").ZodString;
+                    client_id: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                error: import("better-auth").ZodObject<{
+                    error: import("better-auth").ZodEnum<{
+                        invalid_request: "invalid_request";
+                        authorization_pending: "authorization_pending";
+                        slow_down: "slow_down";
+                        expired_token: "expired_token";
+                        access_denied: "access_denied";
+                        invalid_grant: "invalid_grant";
+                    }>;
+                    error_description: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    noStore: boolean;
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            400: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                error: {
+                                                    type: string;
+                                                    enum: string[];
+                                                };
+                                                error_description: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                access_token: string;
+                token_type: string;
+                expires_in: number;
+                scope: string;
+            }>;
+            deviceVerify: BetterCall.StrictEndpoint<"/device", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    user_code: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                error: import("better-auth").ZodObject<{
+                    error: import("better-auth").ZodEnum<{
+                        invalid_request: "invalid_request";
+                    }>;
+                    error_description: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user_code: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                status: {
+                                                    type: string;
+                                                    enum: string[];
+                                                    description: string;
+                                                };
+                                                client_id: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                scope: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                user_code: string;
+                status: string;
+                client_id?: string | undefined;
+                scope?: string | undefined;
+            } & Partial<{
+                resource: string | string[] | undefined;
+            }>>;
+            deviceApprove: BetterCall.StrictEndpoint<"/device/approve", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    userCode: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                error: import("better-auth").ZodObject<{
+                    error: import("better-auth").ZodEnum<{
+                        invalid_request: "invalid_request";
+                        expired_token: "expired_token";
+                        access_denied: "access_denied";
+                        device_code_already_processed: "device_code_already_processed";
+                        unauthorized: "unauthorized";
+                    }>;
+                    error_description: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                requireHeaders: true;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            deviceDeny: BetterCall.StrictEndpoint<"/device/deny", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    userCode: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                error: import("better-auth").ZodObject<{
+                    error: import("better-auth").ZodEnum<{
+                        invalid_request: "invalid_request";
+                        expired_token: "expired_token";
+                        access_denied: "access_denied";
+                        unauthorized: "unauthorized";
+                    }>;
+                    error_description: import("better-auth").ZodString;
+                }, import("zod/v4/core").$strip>;
+                requireHeaders: true;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+        };
+        rateLimit: {
+            pathMatcher(path: string): path is "/device";
+            window: number;
+            max: number;
+        }[];
+        $ERROR_CODES: {
+            USER_NOT_FOUND: import("better-auth").RawError<"USER_NOT_FOUND">;
+            FAILED_TO_CREATE_SESSION: import("better-auth").RawError<"FAILED_TO_CREATE_SESSION">;
+            INVALID_DEVICE_CODE: import("better-auth").RawError<"INVALID_DEVICE_CODE">;
+            EXPIRED_DEVICE_CODE: import("better-auth").RawError<"EXPIRED_DEVICE_CODE">;
+            EXPIRED_USER_CODE: import("better-auth").RawError<"EXPIRED_USER_CODE">;
+            AUTHORIZATION_PENDING: import("better-auth").RawError<"AUTHORIZATION_PENDING">;
+            ACCESS_DENIED: import("better-auth").RawError<"ACCESS_DENIED">;
+            INVALID_USER_CODE: import("better-auth").RawError<"INVALID_USER_CODE">;
+            DEVICE_CODE_ALREADY_PROCESSED: import("better-auth").RawError<"DEVICE_CODE_ALREADY_PROCESSED">;
+            DEVICE_CODE_NOT_CLAIMED: import("better-auth").RawError<"DEVICE_CODE_NOT_CLAIMED">;
+            POLLING_TOO_FREQUENTLY: import("better-auth").RawError<"POLLING_TOO_FREQUENTLY">;
+            INVALID_DEVICE_CODE_STATUS: import("better-auth").RawError<"INVALID_DEVICE_CODE_STATUS">;
+            AUTHENTICATION_REQUIRED: import("better-auth").RawError<"AUTHENTICATION_REQUIRED">;
+        };
+        options: {
+            grant: import("better-auth/plugins").DeviceAuthorizationGrant<Readonly<{
+                [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+            }>, Record<string, unknown>> | undefined;
+            expiresIn: import("better-auth/plugins").TimeString;
+            interval: import("better-auth/plugins").TimeString;
+            deviceCodeLength: number;
+            userCodeLength: number;
+            generateDeviceCode?: (() => string | Promise<string>) | undefined;
+            generateUserCode?: (() => string | Promise<string>) | undefined;
+            validateClient?: ((clientId: string) => boolean | Promise<boolean>) | undefined;
+            onDeviceAuthRequest?: ((clientId: string, scope: string | undefined) => void | Promise<void>) | undefined;
+            verificationUri?: string | undefined;
+            schema?: {
+                deviceCode?: {
+                    modelName?: string | undefined;
+                    fields?: {
+                        deviceCode?: string | undefined;
+                        userCode?: string | undefined;
+                        userId?: string | undefined;
+                        expiresAt?: string | undefined;
+                        status?: string | undefined;
+                        lastPolledAt?: string | undefined;
+                        pollingInterval?: string | undefined;
+                        clientId?: string | undefined;
+                        scope?: string | undefined;
+                    } | undefined;
+                } | undefined;
+            } | undefined;
+        };
+    }];
+    rateLimit: {
+        enabled: false;
+    };
+    secret: string;
+    socialProviders: {
+        google: {
+            clientId: string;
+            clientSecret: string;
+            prompt: "select_account";
+        };
+    } | {
+        google?: never;
+    };
+};
+export declare namespace options {
+    type Options = {
+        /** Decides whether an authorization needs the account step, as `Apps.plugins` describes. */
+        accountStep?: Apps.plugins.Options['accountStep'];
+        /** Tempo ID's origin, such as `https://id.tempo.xyz`. */
+        baseURL: string;
+        /** The Drizzle database that holds Tempo ID's tables. */
+        db: Parameters<typeof drizzleAdapter>[0];
+        /** Google's OAuth client. Absent, Tempo ID offers no Google sign-in. */
+        google?: {
+            clientId: string;
+            clientSecret: string;
+        } | undefined;
+        /** Takes the key authorization that a code's redemption returns, as `Apps.plugins` describes. */
+        pendingKey?: Apps.plugins.Options['pendingKey'];
+        /** The secret that signs cookies and encrypts the signing keys. */
+        secret: string;
+        /** Emails a sign-in code to an address. */
+        sendCode: (options: {
+            code: string;
+            email: string;
+        }) => Promise<void>;
+        /** Keeps work alive after the response, such as `c.executionCtx.waitUntil`. */
+        waitUntil: (promise: Promise<unknown>) => void;
+    };
+}
+export {};
+//# sourceMappingURL=Auth.d.ts.map