@blen/fedreg-mcp-server 2.0.11 → 2.2.0

package/dist/accounts/provider.d.ts

@@ -0,0 +1,2568 @@
+import type { AccountConfig } from './config.js';
+import type { Store } from './store.js';
+export declare const SCOPES: string[];
+/** Same Google / OAuth provider as Data.gov, scoped to personal accounts. */
+export declare function createAuth(config: AccountConfig, store: Store): import("better-auth").Auth<{
+    baseURL: string;
+    basePath: string;
+    secret: string;
+    database: import("pg").Pool;
+    trustedOrigins: string[];
+    logger: {
+        disabled: true;
+    };
+    advanced: {
+        useSecureCookies: boolean;
+    };
+    rateLimit: {
+        enabled: boolean;
+    };
+    session: {
+        expiresIn: number;
+        cookieCache: {
+            enabled: false;
+        };
+    };
+    account: {
+        encryptOAuthTokens: true;
+        accountLinking: {
+            enabled: false;
+        };
+    };
+    emailAndPassword: {
+        enabled: false;
+    };
+    disabledPaths: string[];
+    socialProviders: {
+        google: {
+            clientId: string;
+            clientSecret: string;
+            accessType: "online";
+            prompt: "select_account";
+        };
+    };
+    hooks: {
+        before: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>;
+    };
+    plugins: [{
+        id: "oauth-provider";
+        version: string;
+        options: NoInfer<import("@better-auth/oauth-provider").OAuthOptions<import("@better-auth/oauth-provider").Scope[]>>;
+        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: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>;
+            }[];
+            after: {
+                matcher(ctx: import("better-auth").HookEndpointContext): boolean;
+                handler: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    redirect: true;
+                    url: string;
+                } | undefined>>;
+            }[];
+        };
+        endpoints: {
+            getOAuthServerConfig: import("better-auth").StrictEndpoint<"/.well-known/oauth-authorization-server", {
+                method: "GET";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").AuthServerMetadata>;
+            getOpenIdConfig: import("better-auth").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: import("better-auth").StrictEndpoint<"/oauth2/authorize", {
+                method: ("GET" | "POST")[];
+                body: import("zod").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: import("better-auth").StrictEndpoint<"/oauth2/consent", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    accept: import("zod").ZodBoolean;
+                    scope: import("zod").ZodOptional<import("zod").ZodString>;
+                    claims: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>]>>;
+                    oauth_query: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                redirect_uri: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                redirect: true;
+                url: string;
+            } | {
+                redirect: boolean;
+                url: string;
+            }>;
+            oauth2Continue: import("better-auth").StrictEndpoint<"/oauth2/continue", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    selected: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    created: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    postLogin: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    oauth_query: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                redirect_uri: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                redirect: true;
+                url: string;
+            }>;
+            oauth2Token: import("better-auth").StrictEndpoint<"/oauth2/token", {
+                method: "POST";
+                cloneRequest: true;
+                body: import("zod").ZodObject<{
+                    grant_type: import("zod").ZodString;
+                    client_id: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_secret: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_assertion: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_assertion_type: import("zod").ZodOptional<import("zod").ZodString>;
+                    code: import("zod").ZodOptional<import("zod").ZodString>;
+                    code_verifier: import("zod").ZodOptional<import("zod").ZodString>;
+                    redirect_uri: import("zod").ZodOptional<import("zod").ZodURL>;
+                    refresh_token: import("zod").ZodOptional<import("zod").ZodString>;
+                    resource: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+                    scope: import("zod").ZodOptional<import("zod").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: import("better-auth").StrictEndpoint<"/oauth2/introspect", {
+                method: "POST";
+                cloneRequest: true;
+                body: import("zod").ZodObject<{
+                    client_id: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_secret: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_assertion: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_assertion_type: import("zod").ZodOptional<import("zod").ZodString>;
+                    token: import("zod").ZodString;
+                    token_type_hint: import("zod").ZodOptional<import("zod").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("jose").JWTPayload>;
+            oauth2Revoke: import("better-auth").StrictEndpoint<"/oauth2/revoke", {
+                method: "POST";
+                cloneRequest: true;
+                body: import("zod").ZodObject<{
+                    client_id: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_secret: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_assertion: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_assertion_type: import("zod").ZodOptional<import("zod").ZodString>;
+                    token: import("zod").ZodString;
+                    token_type_hint: import("zod").ZodOptional<import("zod").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: import("better-auth").StrictEndpoint<"/oauth2/userinfo", {
+                method: ("GET" | "POST")[];
+                body: import("zod").ZodOptional<import("zod").ZodObject<{
+                    access_token: import("zod").ZodOptional<import("zod").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: import("better-auth").StrictEndpoint<"/oauth2/end-session", {
+                method: ("GET" | "POST")[];
+                body: import("zod").ZodOptional<import("zod").ZodObject<{
+                    id_token_hint: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_id: import("zod").ZodOptional<import("zod").ZodString>;
+                    post_logout_redirect_uri: import("zod").ZodOptional<import("zod").ZodURL>;
+                    state: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+                query: import("zod").ZodOptional<import("zod").ZodObject<{
+                    id_token_hint: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_id: import("zod").ZodOptional<import("zod").ZodString>;
+                    post_logout_redirect_uri: import("zod").ZodOptional<import("zod").ZodURL>;
+                    state: import("zod").ZodOptional<import("zod").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: import("better-auth").StrictEndpoint<"/oauth2/end-session/confirm", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    action: import("zod").ZodLiteral<"confirm">;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    noStore: boolean;
+                    allowedMediaTypes: string[];
+                    scope: "http";
+                };
+            }, Response | {
+                redirect: true;
+                url: string;
+            } | null>;
+            registerOAuthClient: import("better-auth").StrictEndpoint<"/oauth2/register", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                    scope: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_name: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    logo_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    contacts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    tos_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    policy_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    software_id: import("zod").ZodOptional<import("zod").ZodString>;
+                    software_version: import("zod").ZodOptional<import("zod").ZodString>;
+                    software_statement: import("zod").ZodOptional<import("zod").ZodString>;
+                    post_logout_redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                    backchannel_logout_uri: import("zod").ZodOptional<import("zod").ZodURL>;
+                    backchannel_logout_session_required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    token_endpoint_auth_method: import("zod").ZodOptional<import("zod").ZodString>;
+                    jwks: import("zod").ZodOptional<import("zod").ZodObject<{
+                        keys: import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    }, import("zod/v4/core").$strip>>;
+                    jwks_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    grant_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    response_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                        code: "code";
+                    }>>>;
+                    application_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        web: "web";
+                        native: "native";
+                    }>>;
+                    subject_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        public: "public";
+                        pairwise: "pairwise";
+                    }>>;
+                    dpop_bound_access_tokens: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    resources: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    skip_consent: import("zod").ZodOptional<import("zod").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: import("better-auth").StrictEndpoint<"/admin/oauth2/create-client", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                    scope: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_name: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    logo_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    contacts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    tos_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    policy_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    software_id: import("zod").ZodOptional<import("zod").ZodString>;
+                    software_version: import("zod").ZodOptional<import("zod").ZodString>;
+                    software_statement: import("zod").ZodOptional<import("zod").ZodString>;
+                    post_logout_redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                    backchannel_logout_uri: import("zod").ZodOptional<import("zod").ZodURL>;
+                    backchannel_logout_session_required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    token_endpoint_auth_method: import("zod").ZodOptional<import("zod").ZodString>;
+                    application_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        web: "web";
+                        native: "native";
+                    }>>;
+                    jwks: import("zod").ZodOptional<import("zod").ZodObject<{
+                        keys: import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    }, import("zod/v4/core").$strip>>;
+                    jwks_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    grant_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    client_credentials_scopes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    response_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                        code: "code";
+                    }>>>;
+                    client_secret_expires_at: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>>;
+                    skip_consent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    enable_end_session: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    require_pkce: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    dpop_bound_access_tokens: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    subject_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        public: "public";
+                        pairwise: "pairwise";
+                    }>>;
+                    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").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: import("better-auth").StrictEndpoint<"/oauth2/create-client", {
+                method: "POST";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                body: import("zod").ZodObject<{
+                    redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                    scope: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_name: import("zod").ZodOptional<import("zod").ZodString>;
+                    client_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    logo_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    contacts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    tos_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    policy_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    software_id: import("zod").ZodOptional<import("zod").ZodString>;
+                    software_version: import("zod").ZodOptional<import("zod").ZodString>;
+                    software_statement: import("zod").ZodOptional<import("zod").ZodString>;
+                    post_logout_redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                    backchannel_logout_uri: import("zod").ZodOptional<import("zod").ZodURL>;
+                    backchannel_logout_session_required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    token_endpoint_auth_method: import("zod").ZodOptional<import("zod").ZodString>;
+                    application_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        web: "web";
+                        native: "native";
+                    }>>;
+                    jwks: import("zod").ZodOptional<import("zod").ZodObject<{
+                        keys: import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    }, import("zod/v4/core").$strip>>;
+                    jwks_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                    grant_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    response_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                        code: "code";
+                    }>>>;
+                    dpop_bound_access_tokens: import("zod").ZodOptional<import("zod").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: import("better-auth").StrictEndpoint<"/oauth2/get-client", {
+                method: "GET";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                query: import("zod").ZodObject<{
+                    client_id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            getOAuthClientPublic: import("better-auth").StrictEndpoint<"/oauth2/public-client", {
+                method: "GET";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                query: import("zod").ZodObject<{
+                    client_id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            getOAuthClientPublicPrelogin: import("better-auth").StrictEndpoint<"/oauth2/public-client-prelogin", {
+                method: "POST";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>>[];
+                body: import("zod").ZodObject<{
+                    client_id: import("zod").ZodString;
+                    oauth_query: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            getOAuthClients: import("better-auth").StrictEndpoint<"/oauth2/get-clients", {
+                method: "GET";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient[] | null>;
+            adminUpdateOAuthClient: import("better-auth").StrictEndpoint<"/admin/oauth2/update-client", {
+                method: "PATCH";
+                body: import("zod").ZodObject<{
+                    client_id: import("zod").ZodString;
+                    update: import("zod").ZodObject<{
+                        redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                        scope: import("zod").ZodOptional<import("zod").ZodString>;
+                        client_name: import("zod").ZodOptional<import("zod").ZodString>;
+                        client_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                        logo_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                        contacts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        tos_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                        policy_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                        software_id: import("zod").ZodOptional<import("zod").ZodString>;
+                        software_version: import("zod").ZodOptional<import("zod").ZodString>;
+                        software_statement: import("zod").ZodOptional<import("zod").ZodString>;
+                        post_logout_redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                        backchannel_logout_uri: import("zod").ZodOptional<import("zod").ZodURL>;
+                        backchannel_logout_session_required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        application_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            web: "web";
+                            native: "native";
+                        }>>;
+                        grant_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        client_credentials_scopes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        response_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                            code: "code";
+                        }>>>;
+                        client_secret_expires_at: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                        skip_consent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        enable_end_session: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        dpop_bound_access_tokens: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").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: import("better-auth").StrictEndpoint<"/oauth2/update-client", {
+                method: "POST";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                body: import("zod").ZodObject<{
+                    client_id: import("zod").ZodString;
+                    update: import("zod").ZodObject<{
+                        redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                        scope: import("zod").ZodOptional<import("zod").ZodString>;
+                        client_name: import("zod").ZodOptional<import("zod").ZodString>;
+                        client_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                        logo_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                        contacts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        tos_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                        policy_uri: import("zod").ZodOptional<import("zod").ZodString>;
+                        software_id: import("zod").ZodOptional<import("zod").ZodString>;
+                        software_version: import("zod").ZodOptional<import("zod").ZodString>;
+                        software_statement: import("zod").ZodOptional<import("zod").ZodString>;
+                        post_logout_redirect_uris: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodURL>>;
+                        backchannel_logout_uri: import("zod").ZodOptional<import("zod").ZodURL>;
+                        backchannel_logout_session_required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        application_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            web: "web";
+                            native: "native";
+                        }>>;
+                        grant_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        response_types: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                            code: "code";
+                        }>>>;
+                    }, import("zod/v4/core").$strip>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClientRegistrationResponse>;
+            rotateClientSecret: import("better-auth").StrictEndpoint<"/oauth2/client/rotate-secret", {
+                method: "POST";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                body: import("zod").ZodObject<{
+                    client_id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    noStore: boolean;
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthClient>;
+            deleteOAuthClient: import("better-auth").StrictEndpoint<"/oauth2/delete-client", {
+                method: "POST";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                body: import("zod").ZodObject<{
+                    client_id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, void>;
+            getOAuthConsent: import("better-auth").StrictEndpoint<"/oauth2/get-consent", {
+                method: "GET";
+                query: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthConsent<import("@better-auth/oauth-provider").Scope[]>>;
+            getOAuthConsents: import("better-auth").StrictEndpoint<"/oauth2/get-consents", {
+                method: "GET";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthConsent<import("@better-auth/oauth-provider").Scope[]>[]>;
+            updateOAuthConsent: import("better-auth").StrictEndpoint<"/oauth2/update-consent", {
+                method: "POST";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                body: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    update: import("zod").ZodObject<{
+                        scopes: import("zod").ZodArray<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, import("@better-auth/oauth-provider").OAuthConsent<import("@better-auth/oauth-provider").Scope[]> | null>;
+            deleteOAuthConsent: import("better-auth").StrictEndpoint<"/oauth2/delete-consent", {
+                method: "POST";
+                use: import("better-auth").Middleware<import("better-auth").MiddlewareOptions, (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>>[];
+                body: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                    };
+                };
+            }, void>;
+            adminCreateOAuthResource: import("better-auth").StrictEndpoint<"/admin/oauth2/resources", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    identifier: import("zod").ZodNonOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    accessTokenTtl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                    refreshTokenTtl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                    signingAlgorithm: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<{
+                        RS256: "RS256";
+                        PS256: "PS256";
+                        ES256: "ES256";
+                        ES512: "ES512";
+                        EdDSA: "EdDSA";
+                    }>>>;
+                    signingKeyId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                    allowedScopes: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>>;
+                    customClaims: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+                    dpopBoundAccessTokensRequired: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    disabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    metadata: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").OAuthResource>;
+            adminListOAuthResources: import("better-auth").StrictEndpoint<"/admin/oauth2/resources", {
+                method: "GET";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").OAuthResource[]>;
+            adminGetOAuthResource: import("better-auth").StrictEndpoint<"/admin/oauth2/resources/:identifier", {
+                method: "GET";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").OAuthResource>;
+            adminUpdateOAuthResource: import("better-auth").StrictEndpoint<"/admin/oauth2/resources/:identifier", {
+                method: "PATCH";
+                body: import("zod").ZodObject<{
+                    identifier: import("zod").ZodOptional<import("zod").ZodString>;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    accessTokenTtl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                    refreshTokenTtl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                    signingAlgorithm: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<{
+                        RS256: "RS256";
+                        PS256: "PS256";
+                        ES256: "ES256";
+                        ES512: "ES512";
+                        EdDSA: "EdDSA";
+                    }>>>;
+                    signingKeyId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                    allowedScopes: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>>;
+                    customClaims: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+                    dpopBoundAccessTokensRequired: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    disabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    metadata: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, import("@better-auth/oauth-provider").OAuthResource>;
+            adminDeleteOAuthResource: import("better-auth").StrictEndpoint<"/admin/oauth2/resources/:identifier", {
+                method: "DELETE";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, {
+                deleted: boolean;
+            }>;
+            adminLinkClientResource: import("better-auth").StrictEndpoint<"/admin/oauth2/resources/:identifier/clients/:client_id", {
+                method: "POST";
+                metadata: {
+                    SERVER_ONLY: true;
+                };
+            }, {
+                linked: boolean;
+            }>;
+            adminUnlinkClientResource: import("better-auth").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;
+        })[];
+    }, {
+        id: "cimd";
+        version: string;
+        init(ctx: import("better-auth").AuthContext): void;
+    }];
+}>;
+export type Auth = ReturnType<typeof createAuth>;
+export declare function initializeAuth(auth: Auth, config: AccountConfig, store: Store): Promise<void>;
+//# sourceMappingURL=provider.d.ts.map