@rolder/kit 3.0.0-alpha.11 → 3.0.0-alpha.111

package/dist/betterAuth/server/defaultAuthServerConfig.d.ts

@@ -0,0 +1,1243 @@
+import { type JwtOptions } from 'better-auth/plugins';
+export declare const defaultAuthServerPluginOptions: {
+    admin: {
+        bannedUserMessage: string;
+    };
+    jwt: {
+        jwks: {
+            keyPairConfig: {
+                alg: "EdDSA";
+                crv: "Ed25519";
+            };
+        };
+        jwt: {
+            issuer: string;
+            audience: string;
+            expirationTime: string;
+            definePayload: ({ user, session }: {
+                user: import("better-auth").User & Record<string, any>;
+                session: import("better-auth").Session & Record<string, any>;
+            }) => {
+                id: string;
+                ns: string;
+                db: string;
+                ac: string;
+                email: string;
+                name: string;
+                role: string;
+                sessionId: string;
+            };
+        };
+    };
+};
+export declare const defaultAuthServerConfig: {
+    baseURL: string;
+    secret: string | undefined;
+    database: (options: Parameters<import("better-auth/adapters").AdapterFactory>[0]) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
+    experimental: {
+        joins: boolean;
+    };
+    emailAndPassword: {
+        enabled: boolean;
+    };
+    plugins: ({
+        id: "username";
+        init(ctx: import("better-auth").AuthContext): {
+            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>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                                data: {
+                                    displayUsername?: string | undefined;
+                                    username?: string | undefined;
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                        };
+                        update: {
+                            before(user: Partial<{
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            }> & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                                data: {
+                                    displayUsername?: string | undefined;
+                                    username?: string | undefined;
+                                    id?: string | undefined;
+                                    createdAt?: Date | undefined;
+                                    updatedAt?: Date | undefined;
+                                    email?: string | undefined;
+                                    emailVerified?: boolean | undefined;
+                                    name?: string | undefined;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                        };
+                    };
+                };
+            };
+        };
+        endpoints: {
+            signInUsername: import("better-auth").StrictEndpoint<"/sign-in/username", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    username: import("zod").ZodString;
+                    password: import("zod").ZodString;
+                    rememberMe: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("better-auth").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            422: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                message: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    username: string;
+                    displayUsername: string;
+                };
+            } | null>;
+            isUsernameAvailable: import("better-auth").StrictEndpoint<"/is-username-available", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    username: import("zod").ZodString;
+                }, import("better-auth").$strip>;
+            }, {
+                available: boolean;
+            }>;
+        };
+        schema: {
+            user: {
+                fields: {
+                    username: {
+                        type: "string";
+                        required: false;
+                        sortable: true;
+                        unique: true;
+                        returned: true;
+                        transform: {
+                            input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | unknown[] | Record<string, unknown> | null | undefined;
+                        };
+                    };
+                    displayUsername: {
+                        type: "string";
+                        required: false;
+                        transform: {
+                            input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | unknown[] | Record<string, unknown> | null | undefined;
+                        };
+                    };
+                };
+            };
+        };
+        hooks: {
+            before: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        options: import("better-auth/plugins").UsernameOptions | undefined;
+        $ERROR_CODES: {
+            readonly INVALID_USERNAME_OR_PASSWORD: "Invalid username or password";
+            readonly EMAIL_NOT_VERIFIED: "Email not verified";
+            readonly UNEXPECTED_ERROR: "Unexpected error";
+            readonly USERNAME_IS_ALREADY_TAKEN: "Username is already taken. Please try another.";
+            readonly USERNAME_TOO_SHORT: "Username is too short";
+            readonly USERNAME_TOO_LONG: "Username is too long";
+            readonly INVALID_USERNAME: "Username is invalid";
+            readonly INVALID_DISPLAY_USERNAME: "Display username is invalid";
+        };
+    } | {
+        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 | null): 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: import("better-auth").StrictEndpoint<"/admin/set-role", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                    role: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").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: import("better-auth").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" | "admin" | ("user" | "admin")[];
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins").UserWithRole;
+            }>;
+            getUser: import("better-auth").StrictEndpoint<"/admin/get-user", {
+                method: "GET";
+                query: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                }, import("better-auth").$strip>;
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: import("better-auth").Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("better-auth/plugins").UserWithRole>;
+            createUser: import("better-auth").StrictEndpoint<"/admin/create-user", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                    name: import("zod").ZodString;
+                    role: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+                    data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").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 | undefined;
+                            name: string;
+                            role?: "user" | "admin" | ("user" | "admin")[] | undefined;
+                            data?: Record<string, any> | undefined;
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins").UserWithRole;
+            }>;
+            adminUpdateUser: import("better-auth").StrictEndpoint<"/admin/update-user", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                    data: import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodAny>;
+                }, import("better-auth").$strip>;
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: import("better-auth").Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("better-auth/plugins").UserWithRole>;
+            listUsers: import("better-auth").StrictEndpoint<"/admin/list-users", {
+                method: "GET";
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: import("better-auth").Session;
+                    };
+                }>)[];
+                query: import("zod").ZodObject<{
+                    searchValue: import("zod").ZodOptional<import("zod").ZodString>;
+                    searchField: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        name: "name";
+                        email: "email";
+                    }>>;
+                    searchOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        contains: "contains";
+                        starts_with: "starts_with";
+                        ends_with: "ends_with";
+                    }>>;
+                    limit: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                    offset: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                    sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+                    sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                    filterField: import("zod").ZodOptional<import("zod").ZodString>;
+                    filterValue: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, import("zod").ZodBoolean]>>;
+                    filterOperator: import("zod").ZodOptional<import("zod").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[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                users: import("better-auth/plugins").UserWithRole[];
+                total: number;
+                limit: number | undefined;
+                offset: number | undefined;
+            } | {
+                users: never[];
+                total: number;
+            }>;
+            listUserSessions: import("better-auth").StrictEndpoint<"/admin/list-user-sessions", {
+                method: "POST";
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: import("better-auth").Session;
+                    };
+                }>)[];
+                body: import("zod").ZodObject<{
+                    userId: import("zod").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;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                sessions: import("better-auth/plugins").SessionWithImpersonatedBy[];
+            }>;
+            unbanUser: import("better-auth").StrictEndpoint<"/admin/unban-user", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").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: import("better-auth").Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins").UserWithRole;
+            }>;
+            banUser: import("better-auth").StrictEndpoint<"/admin/ban-user", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                    banReason: import("zod").ZodOptional<import("zod").ZodString>;
+                    banExpiresIn: import("zod").ZodOptional<import("zod").ZodNumber>;
+                }, import("better-auth").$strip>;
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: import("better-auth").Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins").UserWithRole;
+            }>;
+            impersonateUser: import("better-auth").StrictEndpoint<"/admin/impersonate-user", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").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: import("better-auth").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;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                session: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: import("better-auth/plugins").UserWithRole;
+            }>;
+            stopImpersonating: import("better-auth").StrictEndpoint<"/admin/stop-impersonating", {
+                method: "POST";
+                requireHeaders: true;
+            }, {
+                session: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                } & Record<string, any>;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, any>;
+            }>;
+            revokeUserSession: import("better-auth").StrictEndpoint<"/admin/revoke-user-session", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    sessionToken: import("zod").ZodString;
+                }, import("better-auth").$strip>;
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: import("better-auth").Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            revokeUserSessions: import("better-auth").StrictEndpoint<"/admin/revoke-user-sessions", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").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: import("better-auth").Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            removeUser: import("better-auth").StrictEndpoint<"/admin/remove-user", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").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: import("better-auth").Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            setUserPassword: import("better-auth").StrictEndpoint<"/admin/set-user-password", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    newPassword: import("zod").ZodString;
+                    userId: import("zod").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: import("better-auth").Session;
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            userHasPermission: import("better-auth").StrictEndpoint<"/admin/has-permission", {
+                method: "POST";
+                body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                    userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                    role: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("better-auth").$strip>, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    permission: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                    permissions: import("zod").ZodUndefined;
+                }, import("better-auth").$strip>, import("zod").ZodObject<{
+                    permission: import("zod").ZodUndefined;
+                    permissions: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").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?: ("list" | "create" | "update" | "set-role" | "ban" | "impersonate" | "delete" | "set-password" | "get")[] | undefined;
+                                readonly session?: ("list" | "delete" | "revoke")[] | undefined;
+                            };
+                            permissions?: never | undefined;
+                        } | {
+                            permissions: {
+                                readonly user?: ("list" | "create" | "update" | "set-role" | "ban" | "impersonate" | "delete" | "set-password" | "get")[] | undefined;
+                                readonly session?: ("list" | "delete" | "revoke")[] | undefined;
+                            };
+                            permission?: never | undefined;
+                        }) & {
+                            userId?: string | undefined;
+                            role?: "user" | "admin" | undefined;
+                        };
+                    };
+                };
+            }, {
+                error: null;
+                success: boolean;
+            }>;
+        };
+        $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";
+            readonly YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: "You are not allowed to set a non-existent role value";
+            readonly YOU_CANNOT_IMPERSONATE_ADMINS: "You cannot impersonate admins";
+            readonly INVALID_ROLE_TYPE: "Invalid role type";
+        };
+        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: NoInfer<{
+            bannedUserMessage: string;
+        }>;
+    } | {
+        id: "jwt";
+        options: NoInfer<{
+            jwks: {
+                keyPairConfig: {
+                    alg: "EdDSA";
+                    crv: "Ed25519";
+                };
+            };
+            jwt: {
+                issuer: string;
+                audience: string;
+                expirationTime: string;
+                definePayload: ({ user, session }: {
+                    user: import("better-auth").User & Record<string, any>;
+                    session: import("better-auth").Session & Record<string, any>;
+                }) => {
+                    id: string;
+                    ns: string;
+                    db: string;
+                    ac: string;
+                    email: string;
+                    name: string;
+                    role: string;
+                    sessionId: string;
+                };
+            };
+        }>;
+        endpoints: {
+            getJwks: import("better-auth").StrictEndpoint<string, {
+                method: "GET";
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                keys: {
+                                                    type: string;
+                                                    description: string;
+                                                    items: {
+                                                        type: string;
+                                                        properties: {
+                                                            kid: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            kty: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            alg: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            use: {
+                                                                type: string;
+                                                                description: string;
+                                                                enum: string[];
+                                                                nullable: boolean;
+                                                            };
+                                                            n: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            e: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            crv: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            x: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            y: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("better-auth").JSONWebKeySet>;
+            getToken: import("better-auth").StrictEndpoint<"/token", {
+                method: "GET";
+                requireHeaders: true;
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+            }>;
+            signJWT: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                metadata: {
+                    $Infer: {
+                        body: {
+                            payload: import("better-auth").JWTPayload;
+                            overrideOptions?: JwtOptions | undefined;
+                        };
+                    };
+                };
+                body: import("zod").ZodObject<{
+                    payload: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>;
+                    overrideOptions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                }, import("better-auth").$strip>;
+            }, {
+                token: string;
+            }>;
+            verifyJWT: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                metadata: {
+                    $Infer: {
+                        body: {
+                            token: string;
+                            issuer?: string;
+                        };
+                        response: {
+                            payload: {
+                                sub: string;
+                                aud: string;
+                                [key: string]: any;
+                            } | null;
+                        };
+                    };
+                };
+                body: import("zod").ZodObject<{
+                    token: import("zod").ZodString;
+                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("better-auth").$strip>;
+            }, {
+                payload: (import("better-auth").JWTPayload & Required<Pick<import("better-auth").JWTPayload, "sub" | "aud">>) | null;
+            }>;
+        };
+        hooks: {
+            after: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        schema: {
+            jwks: {
+                fields: {
+                    publicKey: {
+                        type: "string";
+                        required: true;
+                    };
+                    privateKey: {
+                        type: "string";
+                        required: true;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                    };
+                    expiresAt: {
+                        type: "date";
+                        required: false;
+                    };
+                };
+            };
+        };
+    } | {
+        id: "tanstack-start-cookies";
+        hooks: {
+            after: {
+                matcher(ctx: import("better-auth").HookEndpointContext): true;
+                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+    })[];
+};