rimecms 0.22.0

package/dist/core/config/auth/better-auth.server.d.ts

@@ -0,0 +1,2738 @@
+import type { MailerActions } from '../../plugins/mailer/index.server.js';
+import type { ConfigContext } from '../../rime.server.js';
+import type { Config } from '../../../types.js';
+export declare function getBaseAuthConfig<const C extends Config>(ctx: {
+    mailer: MailerActions | undefined;
+    config: ConfigContext<C>;
+}): {
+    readonly plugins: ({
+        id: "api-key";
+        $ERROR_CODES: {
+            INVALID_METADATA_TYPE: string;
+            REFILL_AMOUNT_AND_INTERVAL_REQUIRED: string;
+            REFILL_INTERVAL_AND_AMOUNT_REQUIRED: string;
+            USER_BANNED: string;
+            UNAUTHORIZED_SESSION: string;
+            KEY_NOT_FOUND: string;
+            KEY_DISABLED: string;
+            KEY_EXPIRED: string;
+            USAGE_EXCEEDED: string;
+            KEY_NOT_RECOVERABLE: string;
+            EXPIRES_IN_IS_TOO_SMALL: string;
+            EXPIRES_IN_IS_TOO_LARGE: string;
+            INVALID_REMAINING: string;
+            INVALID_PREFIX_LENGTH: string;
+            INVALID_NAME_LENGTH: string;
+            METADATA_DISABLED: string;
+            RATE_LIMIT_EXCEEDED: string;
+            NO_VALUES_TO_UPDATE: string;
+            KEY_DISABLED_EXPIRATION: string;
+            INVALID_API_KEY: string;
+            INVALID_USER_ID_FROM_API_KEY: string;
+            INVALID_API_KEY_GETTER_RETURN_TYPE: string;
+            SERVER_ONLY_PROPERTY: string;
+            FAILED_TO_UPDATE_API_KEY: string;
+            NAME_REQUIRED: string;
+        };
+        hooks: {
+            before: {
+                matcher: (ctx: import("better-auth/*").HookEndpointContext) => boolean;
+                handler: (inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                    session: {
+                        id: string;
+                        token: string;
+                        userId: string;
+                        userAgent: string | null;
+                        ipAddress: string | null;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        expiresAt: Date;
+                    };
+                } | {
+                    context: import("better-auth/*").MiddlewareContext<import("better-auth/*").MiddlewareOptions, import("better-auth/*").AuthContext & {
+                        returned?: unknown;
+                        responseHeaders?: Headers;
+                    }>;
+                }>;
+            }[];
+        };
+        endpoints: {
+            createApiKey: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        name?: string | undefined;
+                        expiresIn?: number | null | undefined;
+                        userId?: unknown;
+                        prefix?: string | undefined;
+                        remaining?: number | null | undefined;
+                        metadata?: any;
+                        refillAmount?: number | undefined;
+                        refillInterval?: number | undefined;
+                        rateLimitTimeWindow?: number | undefined;
+                        rateLimitMax?: number | undefined;
+                        rateLimitEnabled?: boolean | undefined;
+                        permissions?: Record<string, string[]> | undefined;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        key: string;
+                        metadata: any;
+                        permissions: any;
+                        id: string;
+                        name: string | null;
+                        start: string | null;
+                        prefix: string | null;
+                        userId: string;
+                        refillInterval: number | null;
+                        refillAmount: number | null;
+                        lastRefillAt: Date | null;
+                        enabled: boolean;
+                        rateLimitEnabled: boolean;
+                        rateLimitTimeWindow: number | null;
+                        rateLimitMax: number | null;
+                        requestCount: number;
+                        remaining: number | null;
+                        lastRequest: Date | null;
+                        expiresAt: Date | null;
+                        createdAt: Date;
+                        updatedAt: Date;
+                    };
+                } : {
+                    key: string;
+                    metadata: any;
+                    permissions: any;
+                    id: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    userId: string;
+                    refillInterval: number | null;
+                    refillAmount: number | null;
+                    lastRefillAt: Date | null;
+                    enabled: boolean;
+                    rateLimitEnabled: boolean;
+                    rateLimitTimeWindow: number | null;
+                    rateLimitMax: number | null;
+                    requestCount: number;
+                    remaining: number | null;
+                    lastRequest: Date | null;
+                    expiresAt: Date | null;
+                    createdAt: Date;
+                    updatedAt: Date;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        name: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
+                        expiresIn: import("better-auth/*").ZodDefault<import("better-auth/*").ZodNullable<import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>>>;
+                        userId: import("better-auth/*").ZodOptional<import("better-auth/*").ZodCoercedString<unknown>>;
+                        prefix: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
+                        remaining: import("better-auth/*").ZodDefault<import("better-auth/*").ZodNullable<import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>>>;
+                        metadata: import("better-auth/*").ZodOptional<import("better-auth/*").ZodAny>;
+                        refillAmount: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                        refillInterval: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                        rateLimitTimeWindow: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                        rateLimitMax: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                        rateLimitEnabled: import("better-auth/*").ZodOptional<import("better-auth/*").ZodBoolean>;
+                        permissions: import("better-auth/*").ZodOptional<import("better-auth/*").ZodRecord<import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>>>;
+                    }, import("better-auth/*").$strip>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    id: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    createdAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        description: string;
+                                                    };
+                                                    updatedAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        description: string;
+                                                    };
+                                                    name: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    prefix: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    start: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    key: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    enabled: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    expiresAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    userId: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    lastRefillAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    lastRequest: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    metadata: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        additionalProperties: boolean;
+                                                        description: string;
+                                                    };
+                                                    rateLimitMax: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    rateLimitTimeWindow: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    remaining: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    refillAmount: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    refillInterval: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    rateLimitEnabled: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    requestCount: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    permissions: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        additionalProperties: {
+                                                            type: string;
+                                                            items: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/api-key/create";
+            };
+            verifyApiKey: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        key: string;
+                        permissions?: Record<string, string[]> | undefined;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        valid: boolean;
+                        error: {
+                            message: string | undefined;
+                            code: string;
+                        };
+                        key: null;
+                    } | {
+                        valid: boolean;
+                        error: null;
+                        key: Omit<{
+                            id: string;
+                            name: string | null;
+                            start: string | null;
+                            prefix: string | null;
+                            key: string;
+                            userId: string;
+                            refillInterval: number | null;
+                            refillAmount: number | null;
+                            lastRefillAt: Date | null;
+                            enabled: boolean;
+                            rateLimitEnabled: boolean;
+                            rateLimitTimeWindow: number | null;
+                            rateLimitMax: number | null;
+                            requestCount: number;
+                            remaining: number | null;
+                            lastRequest: Date | null;
+                            expiresAt: Date | null;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            metadata: Record<string, any> | null;
+                            permissions?: {
+                                [key: string]: string[];
+                            } | null;
+                        }, "key"> | null;
+                    };
+                } : {
+                    valid: boolean;
+                    error: {
+                        message: string | undefined;
+                        code: string;
+                    };
+                    key: null;
+                } | {
+                    valid: boolean;
+                    error: null;
+                    key: Omit<{
+                        id: string;
+                        name: string | null;
+                        start: string | null;
+                        prefix: string | null;
+                        key: string;
+                        userId: string;
+                        refillInterval: number | null;
+                        refillAmount: number | null;
+                        lastRefillAt: Date | null;
+                        enabled: boolean;
+                        rateLimitEnabled: boolean;
+                        rateLimitTimeWindow: number | null;
+                        rateLimitMax: number | null;
+                        requestCount: number;
+                        remaining: number | null;
+                        lastRequest: Date | null;
+                        expiresAt: Date | null;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        metadata: Record<string, any> | null;
+                        permissions?: {
+                            [key: string]: string[];
+                        } | null;
+                    }, "key"> | null;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        key: import("better-auth/*").ZodString;
+                        permissions: import("better-auth/*").ZodOptional<import("better-auth/*").ZodRecord<import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>>>;
+                    }, import("better-auth/*").$strip>;
+                    metadata: {
+                        SERVER_ONLY: true;
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/api-key/verify";
+            };
+            getApiKey: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body?: undefined;
+                } & {
+                    method?: "GET" | undefined;
+                } & {
+                    query: {
+                        id: string;
+                    };
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        permissions: {
+                            [key: string]: string[];
+                        } | null;
+                        id: string;
+                        name: string | null;
+                        start: string | null;
+                        prefix: string | null;
+                        userId: string;
+                        refillInterval: number | null;
+                        refillAmount: number | null;
+                        lastRefillAt: Date | null;
+                        enabled: boolean;
+                        rateLimitEnabled: boolean;
+                        rateLimitTimeWindow: number | null;
+                        rateLimitMax: number | null;
+                        requestCount: number;
+                        remaining: number | null;
+                        lastRequest: Date | null;
+                        expiresAt: Date | null;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        metadata: Record<string, any> | null;
+                    };
+                } : {
+                    permissions: {
+                        [key: string]: string[];
+                    } | null;
+                    id: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    userId: string;
+                    refillInterval: number | null;
+                    refillAmount: number | null;
+                    lastRefillAt: Date | null;
+                    enabled: boolean;
+                    rateLimitEnabled: boolean;
+                    rateLimitTimeWindow: number | null;
+                    rateLimitMax: number | null;
+                    requestCount: number;
+                    remaining: number | null;
+                    lastRequest: Date | null;
+                    expiresAt: Date | null;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    metadata: Record<string, any> | null;
+                }>;
+                options: {
+                    method: "GET";
+                    query: import("better-auth/*").ZodObject<{
+                        id: import("better-auth/*").ZodString;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    id: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    name: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    start: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    prefix: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    userId: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    refillInterval: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    refillAmount: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    lastRefillAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    enabled: {
+                                                        type: string;
+                                                        description: string;
+                                                        default: boolean;
+                                                    };
+                                                    rateLimitEnabled: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    rateLimitTimeWindow: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    rateLimitMax: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    requestCount: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    remaining: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    lastRequest: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    expiresAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    createdAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        description: string;
+                                                    };
+                                                    updatedAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        description: string;
+                                                    };
+                                                    metadata: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        additionalProperties: boolean;
+                                                        description: string;
+                                                    };
+                                                    permissions: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/api-key/get";
+            };
+            updateApiKey: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        keyId: string;
+                        userId?: unknown;
+                        name?: string | undefined;
+                        enabled?: boolean | undefined;
+                        remaining?: number | undefined;
+                        refillAmount?: number | undefined;
+                        refillInterval?: number | undefined;
+                        metadata?: any;
+                        expiresIn?: number | null | undefined;
+                        rateLimitEnabled?: boolean | undefined;
+                        rateLimitTimeWindow?: number | undefined;
+                        rateLimitMax?: number | undefined;
+                        permissions?: Record<string, string[]> | null | undefined;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        permissions: {
+                            [key: string]: string[];
+                        } | null;
+                        id: string;
+                        name: string | null;
+                        start: string | null;
+                        prefix: string | null;
+                        userId: string;
+                        refillInterval: number | null;
+                        refillAmount: number | null;
+                        lastRefillAt: Date | null;
+                        enabled: boolean;
+                        rateLimitEnabled: boolean;
+                        rateLimitTimeWindow: number | null;
+                        rateLimitMax: number | null;
+                        requestCount: number;
+                        remaining: number | null;
+                        lastRequest: Date | null;
+                        expiresAt: Date | null;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        metadata: Record<string, any> | null;
+                    };
+                } : {
+                    permissions: {
+                        [key: string]: string[];
+                    } | null;
+                    id: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    userId: string;
+                    refillInterval: number | null;
+                    refillAmount: number | null;
+                    lastRefillAt: Date | null;
+                    enabled: boolean;
+                    rateLimitEnabled: boolean;
+                    rateLimitTimeWindow: number | null;
+                    rateLimitMax: number | null;
+                    requestCount: number;
+                    remaining: number | null;
+                    lastRequest: Date | null;
+                    expiresAt: Date | null;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    metadata: Record<string, any> | null;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        keyId: import("better-auth/*").ZodString;
+                        userId: import("better-auth/*").ZodOptional<import("better-auth/*").ZodCoercedString<unknown>>;
+                        name: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
+                        enabled: import("better-auth/*").ZodOptional<import("better-auth/*").ZodBoolean>;
+                        remaining: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                        refillAmount: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                        refillInterval: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                        metadata: import("better-auth/*").ZodOptional<import("better-auth/*").ZodAny>;
+                        expiresIn: import("better-auth/*").ZodNullable<import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>>;
+                        rateLimitEnabled: import("better-auth/*").ZodOptional<import("better-auth/*").ZodBoolean>;
+                        rateLimitTimeWindow: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                        rateLimitMax: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                        permissions: import("better-auth/*").ZodNullable<import("better-auth/*").ZodOptional<import("better-auth/*").ZodRecord<import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>>>>;
+                    }, import("better-auth/*").$strip>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    id: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    name: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    start: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    prefix: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    userId: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    refillInterval: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    refillAmount: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    lastRefillAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    enabled: {
+                                                        type: string;
+                                                        description: string;
+                                                        default: boolean;
+                                                    };
+                                                    rateLimitEnabled: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    rateLimitTimeWindow: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    rateLimitMax: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    requestCount: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                    remaining: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    lastRequest: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    expiresAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                    createdAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        description: string;
+                                                    };
+                                                    updatedAt: {
+                                                        type: string;
+                                                        format: string;
+                                                        description: string;
+                                                    };
+                                                    metadata: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        additionalProperties: boolean;
+                                                        description: string;
+                                                    };
+                                                    permissions: {
+                                                        type: string;
+                                                        nullable: boolean;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/api-key/update";
+            };
+            deleteApiKey: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        keyId: string;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        success: boolean;
+                    };
+                } : {
+                    success: boolean;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        keyId: import("better-auth/*").ZodString;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            requestBody: {
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                keyId: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                        description: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/api-key/delete";
+            };
+            listApiKeys: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                    body?: undefined;
+                } & {
+                    method?: "GET" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        permissions: {
+                            [key: string]: string[];
+                        } | null;
+                        id: string;
+                        name: string | null;
+                        start: string | null;
+                        prefix: string | null;
+                        userId: string;
+                        refillInterval: number | null;
+                        refillAmount: number | null;
+                        lastRefillAt: Date | null;
+                        enabled: boolean;
+                        rateLimitEnabled: boolean;
+                        rateLimitTimeWindow: number | null;
+                        rateLimitMax: number | null;
+                        requestCount: number;
+                        remaining: number | null;
+                        lastRequest: Date | null;
+                        expiresAt: Date | null;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        metadata: Record<string, any> | null;
+                    }[];
+                } : {
+                    permissions: {
+                        [key: string]: string[];
+                    } | null;
+                    id: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    userId: string;
+                    refillInterval: number | null;
+                    refillAmount: number | null;
+                    lastRefillAt: Date | null;
+                    enabled: boolean;
+                    rateLimitEnabled: boolean;
+                    rateLimitTimeWindow: number | null;
+                    rateLimitMax: number | null;
+                    requestCount: number;
+                    remaining: number | null;
+                    lastRequest: Date | null;
+                    expiresAt: Date | null;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    metadata: Record<string, any> | null;
+                }[]>;
+                options: {
+                    method: "GET";
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            session: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            };
+                            user: Record<string, any> & {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            };
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "array";
+                                                items: {
+                                                    type: string;
+                                                    properties: {
+                                                        id: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        name: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        start: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        prefix: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        userId: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        refillInterval: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        refillAmount: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        lastRefillAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        enabled: {
+                                                            type: string;
+                                                            description: string;
+                                                            default: boolean;
+                                                        };
+                                                        rateLimitEnabled: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        rateLimitTimeWindow: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        rateLimitMax: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        requestCount: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        remaining: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        lastRequest: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        expiresAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        updatedAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        metadata: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            additionalProperties: boolean;
+                                                            description: string;
+                                                        };
+                                                        permissions: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/api-key/list";
+            };
+            deleteAllExpiredApiKeys: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                    body?: undefined;
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        success: boolean;
+                        error: unknown;
+                    };
+                } : {
+                    success: boolean;
+                    error: unknown;
+                }>;
+                options: {
+                    method: "POST";
+                    metadata: {
+                        SERVER_ONLY: true;
+                        client: boolean;
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/api-key/delete-all-expired-api-keys";
+            };
+        };
+        schema: {
+            apikey: {
+                fields: {
+                    name: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    start: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    prefix: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    key: {
+                        type: "string";
+                        required: true;
+                        input: false;
+                    };
+                    userId: {
+                        type: "string";
+                        references: {
+                            model: string;
+                            field: string;
+                            onDelete: "cascade";
+                        };
+                        required: true;
+                        input: false;
+                    };
+                    refillInterval: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                    };
+                    refillAmount: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                    };
+                    lastRefillAt: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                    enabled: {
+                        type: "boolean";
+                        required: false;
+                        input: false;
+                        defaultValue: true;
+                    };
+                    rateLimitEnabled: {
+                        type: "boolean";
+                        required: false;
+                        input: false;
+                        defaultValue: true;
+                    };
+                    rateLimitTimeWindow: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                        defaultValue: number;
+                    };
+                    rateLimitMax: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                        defaultValue: number;
+                    };
+                    requestCount: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                        defaultValue: number;
+                    };
+                    remaining: {
+                        type: "number";
+                        required: false;
+                        input: false;
+                    };
+                    lastRequest: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                    expiresAt: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                        input: false;
+                    };
+                    updatedAt: {
+                        type: "date";
+                        required: true;
+                        input: false;
+                    };
+                    permissions: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    metadata: {
+                        type: "string";
+                        required: false;
+                        input: true;
+                        transform: {
+                            input(value: packages_core_dist_db.DBPrimitive): string;
+                            output(value: packages_core_dist_db.DBPrimitive): any;
+                        };
+                    };
+                };
+            };
+        };
+    } | {
+        id: "admin";
+        init(): {
+            options: {
+                databaseHooks: {
+                    user: {
+                        create: {
+                            before(user: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            } & Record<string, unknown>): Promise<{
+                                data: {
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                    role: string;
+                                };
+                            }>;
+                        };
+                    };
+                    session: {
+                        create: {
+                            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>, ctx: import("better-auth/*").GenericEndpointContext | undefined): Promise<void>;
+                        };
+                    };
+                };
+            };
+        };
+        hooks: {
+            after: {
+                matcher(context: import("better-auth/*").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<import("better-auth/plugins").SessionWithImpersonatedBy[] | undefined>;
+            }[];
+        };
+        endpoints: {
+            setRole: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        userId: string;
+                        role: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[];
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        user: import("better-auth/plugins").UserWithRole;
+                    };
+                } : {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        userId: import("better-auth/*").ZodCoercedString<unknown>;
+                        role: import("better-auth/*").ZodUnion<readonly [import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>]>;
+                    }, import("better-auth/*").$strip>;
+                    requireHeaders: true;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                userId: string;
+                                role: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[];
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/set-role";
+            };
+            getUser: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body?: undefined;
+                } & {
+                    method?: "GET" | undefined;
+                } & {
+                    query: {
+                        id: string;
+                    };
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                } : {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                }>;
+                options: {
+                    method: "GET";
+                    query: import("better-auth/*").ZodObject<{
+                        id: import("better-auth/*").ZodString;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/get-user";
+            };
+            createUser: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        email: string;
+                        password: string;
+                        name: string;
+                        role?: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[] | undefined;
+                        data?: Record<string, any>;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        user: import("better-auth/plugins").UserWithRole;
+                    };
+                } : {
+                    user: import("better-auth/plugins").UserWithRole;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        email: import("better-auth/*").ZodString;
+                        password: import("better-auth/*").ZodString;
+                        name: import("better-auth/*").ZodString;
+                        role: import("better-auth/*").ZodOptional<import("better-auth/*").ZodUnion<readonly [import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>]>>;
+                        data: import("better-auth/*").ZodOptional<import("better-auth/*").ZodRecord<import("better-auth/*").ZodString, import("better-auth/*").ZodAny>>;
+                    }, import("better-auth/*").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: {
+                                email: string;
+                                password: string;
+                                name: string;
+                                role?: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[] | undefined;
+                                data?: Record<string, any>;
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/create-user";
+            };
+            adminUpdateUser: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        userId: unknown;
+                        data: Record<any, any>;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: import("better-auth/plugins").UserWithRole;
+                } : import("better-auth/plugins").UserWithRole>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        userId: import("better-auth/*").ZodCoercedString<unknown>;
+                        data: import("better-auth/*").ZodRecord<import("better-auth/*").ZodAny, import("better-auth/*").ZodAny>;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/update-user";
+            };
+            listUsers: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body?: undefined;
+                } & {
+                    method?: "GET" | undefined;
+                } & {
+                    query: {
+                        searchValue?: string | undefined;
+                        searchField?: "name" | "email" | undefined;
+                        searchOperator?: "contains" | "starts_with" | "ends_with" | undefined;
+                        limit?: string | number | undefined;
+                        offset?: string | number | undefined;
+                        sortBy?: string | undefined;
+                        sortDirection?: "asc" | "desc" | undefined;
+                        filterField?: string | undefined;
+                        filterValue?: string | number | boolean | undefined;
+                        filterOperator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "contains" | undefined;
+                    };
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        users: import("better-auth/plugins").UserWithRole[];
+                        total: number;
+                        limit: number | undefined;
+                        offset: number | undefined;
+                    } | {
+                        users: never[];
+                        total: number;
+                    };
+                } : {
+                    users: import("better-auth/plugins").UserWithRole[];
+                    total: number;
+                    limit: number | undefined;
+                    offset: number | undefined;
+                } | {
+                    users: never[];
+                    total: number;
+                }>;
+                options: {
+                    method: "GET";
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    query: import("better-auth/*").ZodObject<{
+                        searchValue: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
+                        searchField: import("better-auth/*").ZodOptional<import("better-auth/*").ZodEnum<{
+                            name: "name";
+                            email: "email";
+                        }>>;
+                        searchOperator: import("better-auth/*").ZodOptional<import("better-auth/*").ZodEnum<{
+                            contains: "contains";
+                            starts_with: "starts_with";
+                            ends_with: "ends_with";
+                        }>>;
+                        limit: import("better-auth/*").ZodOptional<import("better-auth/*").ZodUnion<[import("better-auth/*").ZodString, import("better-auth/*").ZodNumber]>>;
+                        offset: import("better-auth/*").ZodOptional<import("better-auth/*").ZodUnion<[import("better-auth/*").ZodString, import("better-auth/*").ZodNumber]>>;
+                        sortBy: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
+                        sortDirection: import("better-auth/*").ZodOptional<import("better-auth/*").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>>;
+                        filterField: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
+                        filterValue: import("better-auth/*").ZodOptional<import("better-auth/*").ZodUnion<[import("better-auth/*").ZodUnion<[import("better-auth/*").ZodString, import("better-auth/*").ZodNumber]>, import("better-auth/*").ZodBoolean]>>;
+                        filterOperator: import("better-auth/*").ZodOptional<import("better-auth/*").ZodEnum<{
+                            eq: "eq";
+                            ne: "ne";
+                            lt: "lt";
+                            lte: "lte";
+                            gt: "gt";
+                            gte: "gte";
+                            contains: "contains";
+                        }>>;
+                    }, import("better-auth/*").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    users: {
+                                                        type: string;
+                                                        items: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                    total: {
+                                                        type: string;
+                                                    };
+                                                    limit: {
+                                                        type: string;
+                                                    };
+                                                    offset: {
+                                                        type: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/list-users";
+            };
+            listUserSessions: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        userId: unknown;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        sessions: import("better-auth/plugins").SessionWithImpersonatedBy[];
+                    };
+                } : {
+                    sessions: import("better-auth/plugins").SessionWithImpersonatedBy[];
+                }>;
+                options: {
+                    method: "POST";
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    body: import("better-auth/*").ZodObject<{
+                        userId: import("better-auth/*").ZodCoercedString<unknown>;
+                    }, import("better-auth/*").$strip>;
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    sessions: {
+                                                        type: string;
+                                                        items: {
+                                                            $ref: string;
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/list-user-sessions";
+            };
+            unbanUser: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        userId: unknown;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        user: any;
+                    };
+                } : {
+                    user: any;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        userId: import("better-auth/*").ZodCoercedString<unknown>;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/unban-user";
+            };
+            banUser: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        userId: unknown;
+                        banReason?: string | undefined;
+                        banExpiresIn?: number | undefined;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        user: any;
+                    };
+                } : {
+                    user: any;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        userId: import("better-auth/*").ZodCoercedString<unknown>;
+                        banReason: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
+                        banExpiresIn: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/ban-user";
+            };
+            impersonateUser: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        userId: unknown;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                } : {
+                    session: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
+                    };
+                    user: {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        userId: import("better-auth/*").ZodCoercedString<unknown>;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    session: {
+                                                        $ref: string;
+                                                    };
+                                                    user: {
+                                                        $ref: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/impersonate-user";
+            };
+            stopImpersonating: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body?: undefined;
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        session: Session & Record<string, any>;
+                        user: packages_core_dist_db.User & Record<string, any>;
+                    };
+                } : {
+                    session: Session & Record<string, any>;
+                    user: packages_core_dist_db.User & Record<string, any>;
+                }>;
+                options: {
+                    method: "POST";
+                    requireHeaders: true;
+                } & {
+                    use: any[];
+                };
+                path: "/admin/stop-impersonating";
+            };
+            revokeUserSession: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        sessionToken: string;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        success: boolean;
+                    };
+                } : {
+                    success: boolean;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        sessionToken: import("better-auth/*").ZodString;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/revoke-user-session";
+            };
+            revokeUserSessions: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        userId: unknown;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        success: boolean;
+                    };
+                } : {
+                    success: boolean;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        userId: import("better-auth/*").ZodCoercedString<unknown>;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/revoke-user-sessions";
+            };
+            removeUser: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        userId: unknown;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        success: boolean;
+                    };
+                } : {
+                    success: boolean;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        userId: import("better-auth/*").ZodCoercedString<unknown>;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/remove-user";
+            };
+            setUserPassword: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: {
+                        newPassword: string;
+                        userId: unknown;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        status: boolean;
+                    };
+                } : {
+                    status: boolean;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodObject<{
+                        newPassword: import("better-auth/*").ZodString;
+                        userId: import("better-auth/*").ZodCoercedString<unknown>;
+                    }, import("better-auth/*").$strip>;
+                    use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                        session: {
+                            user: import("better-auth/plugins").UserWithRole;
+                            session: Session;
+                        };
+                    }>)[];
+                    metadata: {
+                        openapi: {
+                            operationId: string;
+                            summary: string;
+                            description: string;
+                            responses: {
+                                200: {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    status: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/set-user-password";
+            };
+            userHasPermission: {
+                <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                    body: ({
+                        permission: {
+                            readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                            readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                        };
+                        permissions?: never;
+                    } | {
+                        permissions: {
+                            readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                            readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                        };
+                        permission?: never;
+                    }) & {
+                        userId?: string;
+                        role?: "user" | "staff" | "admin" | undefined;
+                    };
+                } & {
+                    method?: "POST" | undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    params?: Record<string, any>;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: import("better-auth/*").Middleware[];
+                    path?: string;
+                } & {
+                    asResponse?: AsResponse | undefined;
+                    returnHeaders?: ReturnHeaders | undefined;
+                }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                    headers: Headers;
+                    response: {
+                        error: null;
+                        success: boolean;
+                    };
+                } : {
+                    error: null;
+                    success: boolean;
+                }>;
+                options: {
+                    method: "POST";
+                    body: import("better-auth/*").ZodIntersection<import("better-auth/*").ZodObject<{
+                        userId: import("better-auth/*").ZodOptional<import("better-auth/*").ZodCoercedString<unknown>>;
+                        role: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
+                    }, import("better-auth/*").$strip>, import("better-auth/*").ZodUnion<readonly [import("better-auth/*").ZodObject<{
+                        permission: import("better-auth/*").ZodRecord<import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>>;
+                        permissions: import("better-auth/*").ZodUndefined;
+                    }, import("better-auth/*").$strip>, import("better-auth/*").ZodObject<{
+                        permission: import("better-auth/*").ZodUndefined;
+                        permissions: import("better-auth/*").ZodRecord<import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>>;
+                    }, import("better-auth/*").$strip>]>>;
+                    metadata: {
+                        openapi: {
+                            description: string;
+                            requestBody: {
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                permission: {
+                                                    type: string;
+                                                    description: string;
+                                                    deprecated: boolean;
+                                                };
+                                                permissions: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            responses: {
+                                "200": {
+                                    description: string;
+                                    content: {
+                                        "application/json": {
+                                            schema: {
+                                                type: "object";
+                                                properties: {
+                                                    error: {
+                                                        type: string;
+                                                    };
+                                                    success: {
+                                                        type: string;
+                                                    };
+                                                };
+                                                required: string[];
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        $Infer: {
+                            body: ({
+                                permission: {
+                                    readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                    readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                                };
+                                permissions?: never;
+                            } | {
+                                permissions: {
+                                    readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                    readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                                };
+                                permission?: never;
+                            }) & {
+                                userId?: string;
+                                role?: "user" | "staff" | "admin" | undefined;
+                            };
+                        };
+                    };
+                } & {
+                    use: any[];
+                };
+                path: "/admin/has-permission";
+            };
+        };
+        $ERROR_CODES: {
+            readonly FAILED_TO_CREATE_USER: "Failed to create user";
+            readonly USER_ALREADY_EXISTS: "User already exists.";
+            readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
+            readonly YOU_CANNOT_BAN_YOURSELF: "You cannot ban yourself";
+            readonly YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: "You are not allowed to change users role";
+            readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: "You are not allowed to create users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: "You are not allowed to list users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: "You are not allowed to list users sessions";
+            readonly YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: "You are not allowed to ban users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: "You are not allowed to impersonate users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: "You are not allowed to revoke users sessions";
+            readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: "You are not allowed to delete users";
+            readonly YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: "You are not allowed to set users password";
+            readonly BANNED_USER: "You have been banned from this application";
+            readonly YOU_ARE_NOT_ALLOWED_TO_GET_USER: "You are not allowed to get user";
+            readonly NO_DATA_TO_UPDATE: "No data to update";
+            readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: "You are not allowed to update users";
+            readonly YOU_CANNOT_REMOVE_YOURSELF: "You cannot remove yourself";
+        };
+        schema: {
+            user: {
+                fields: {
+                    role: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    banned: {
+                        type: "boolean";
+                        defaultValue: false;
+                        required: false;
+                        input: false;
+                    };
+                    banReason: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    banExpires: {
+                        type: "date";
+                        required: false;
+                        input: false;
+                    };
+                };
+            };
+            session: {
+                fields: {
+                    impersonatedBy: {
+                        type: "string";
+                        required: false;
+                    };
+                };
+            };
+        };
+        options: any;
+    })[];
+    readonly rateLimit: {
+        readonly enabled: boolean;
+        readonly window: 10;
+        readonly max: 30;
+    };
+    readonly trustedOrigins: string[];
+    readonly session: {
+        readonly modelName: "authSessions";
+    };
+    readonly account: {
+        readonly modelName: "authAccounts";
+    };
+    readonly verification: {
+        readonly modelName: "authVerifications";
+    };
+    readonly user: {
+        readonly modelName: "authUsers";
+        readonly changeEmail: {
+            readonly enabled: true;
+        };
+        readonly deleteUser: {
+            readonly enabled: true;
+        };
+        readonly additionalFields: {
+            readonly type: {
+                readonly type: "string";
+                readonly required: true;
+            };
+        };
+    };
+    readonly hooks: {
+        readonly before: (inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<unknown>;
+        readonly after: (inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<unknown>;
+    };
+    readonly emailAndPassword: {
+        readonly enabled: true;
+        readonly sendResetPassword: (data: {
+            user: any;
+            url: string;
+        }) => Promise<void>;
+    };
+};