@aitlabs/namkwong 0.0.92

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

@@ -0,0 +1,3278 @@
+import type { BetterAuthPlugin } from 'better-auth';
+import type { BetterAuthOptions } from 'better-auth/minimal';
+import * as roles from './roles';
+export declare const auth: import("better-auth").Auth<{
+    readonly database: (options: BetterAuthOptions) => import("better-auth").DBAdapter<BetterAuthOptions>;
+    readonly databaseHooks: {
+        readonly user: {
+            readonly create: {
+                readonly after: (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<void>;
+            };
+        };
+    };
+    readonly user: {
+        readonly changeEmail: {
+            readonly enabled: true;
+            readonly sendChangeEmailConfirmation: ({ user, newEmail, url, token }: {
+                user: import("better-auth").User;
+                newEmail: string;
+                url: string;
+                token: string;
+            }, request: Request | undefined) => Promise<void>;
+            readonly updateEmailWithoutVerification: true;
+        };
+    };
+    readonly hooks: {
+        readonly before: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+    };
+    readonly emailAndPassword: {
+        readonly enabled: true;
+        readonly autoSignIn: true;
+        readonly sendResetPassword: ({ user, url, token }: {
+            user: import("better-auth").User;
+            url: string;
+            token: string;
+        }, request: Request | undefined) => Promise<void>;
+    };
+    readonly emailVerification: {
+        readonly afterEmailVerification: (user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        }, request: Request | undefined) => Promise<void>;
+        readonly sendOnSignUp: true;
+        readonly sendVerificationEmail: ({ user, url, token }: {
+            user: import("better-auth").User;
+            url: string;
+            token: string;
+        }, request: Request | undefined) => Promise<void>;
+    };
+    readonly trustedOrigins: (request: Request | undefined) => (string | null | undefined)[];
+    readonly advanced: {
+        readonly cookiePrefix: 'namkwong';
+        readonly crossSubDomainCookies: {
+            readonly enabled: boolean;
+            readonly domain: string;
+        };
+    };
+    readonly disabledPaths: ["/is-username-available"];
+    readonly appName: 'My App';
+    readonly plugins: [BetterAuthPlugin, {
+        id: "bearer";
+        version: string;
+        hooks: {
+            before: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    context: {
+                        headers: Headers;
+                    };
+                } | undefined>;
+            }[];
+            after: {
+                matcher(context: import("better-auth").HookEndpointContext): true;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        options: import("better-auth/plugins").BearerOptions | undefined;
+    }, {
+        id: "two-factor";
+        version: string;
+        endpoints: {
+            enableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/enable", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                    password: import("zod").ZodString;
+                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                totpURI: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                backupCodes: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                totpURI: string;
+                backupCodes: string[];
+            }>;
+            disableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/disable", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                    password: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    code: import("zod").ZodString;
+                    disableSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    type: string;
+                                                    properties: {
+                                                        id: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        email: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        emailVerified: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        name: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        image: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        twoFactorEnabled: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        updatedAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                    description: string;
+                                                };
+                                                session: {
+                                                    type: string;
+                                                    properties: {
+                                                        token: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        userId: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        expiresAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string | undefined;
+                user: (Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                }) | import("better-auth/plugins").UserWithTwoFactor;
+            }>;
+            generateBackupCodes: import("better-call").StrictEndpoint<"/two-factor/generate-backup-codes", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                    password: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                                backupCodes: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+                backupCodes: string[];
+            }>;
+            viewBackupCodes: import("better-call").StrictEndpoint<string, {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+            }, {
+                status: boolean;
+                backupCodes: string[];
+            }>;
+            sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
+                method: "POST";
+                body: import("zod").ZodOptional<import("zod").ZodObject<{
+                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    code: import("zod").ZodString;
+                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    type: string;
+                                                    properties: {
+                                                        id: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        email: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        emailVerified: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        name: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        image: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        updatedAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: import("better-auth/plugins").UserWithTwoFactor;
+            } | {
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }>;
+            generateTOTP: import("better-call").StrictEndpoint<string, {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    secret: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                code: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                code: string;
+            }>;
+            getTOTPURI: import("better-call").StrictEndpoint<"/two-factor/get-totp-uri", {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                body: import("zod").ZodObject<{
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                    password: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                totpURI: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                totpURI: string;
+            }>;
+            verifyTOTP: import("better-call").StrictEndpoint<"/two-factor/verify-totp", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    code: import("zod").ZodString;
+                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: import("better-auth/plugins").UserWithTwoFactor;
+            } | {
+                token: string;
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }>;
+        };
+        options: NoInfer<import("better-auth/plugins").TwoFactorOptions>;
+        hooks: {
+            after: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    twoFactorRedirect: boolean;
+                    twoFactorMethods: string[];
+                } | undefined>;
+            }[];
+        };
+        schema: {
+            user: {
+                fields: {
+                    twoFactorEnabled: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: false;
+                        input: false;
+                    };
+                };
+            };
+            twoFactor: {
+                fields: {
+                    secret: {
+                        type: "string";
+                        required: true;
+                        returned: false;
+                        index: true;
+                    };
+                    backupCodes: {
+                        type: "string";
+                        required: true;
+                        returned: false;
+                    };
+                    userId: {
+                        type: "string";
+                        required: true;
+                        returned: false;
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                        index: true;
+                    };
+                    verified: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: true;
+                        input: false;
+                    };
+                };
+            };
+        };
+        rateLimit: {
+            pathMatcher(path: string): boolean;
+            window: number;
+            max: number;
+        }[];
+        $ERROR_CODES: {
+            OTP_NOT_ENABLED: import("better-auth").RawError<"OTP_NOT_ENABLED">;
+            OTP_HAS_EXPIRED: import("better-auth").RawError<"OTP_HAS_EXPIRED">;
+            TOTP_NOT_ENABLED: import("better-auth").RawError<"TOTP_NOT_ENABLED">;
+            TWO_FACTOR_NOT_ENABLED: import("better-auth").RawError<"TWO_FACTOR_NOT_ENABLED">;
+            BACKUP_CODES_NOT_ENABLED: import("better-auth").RawError<"BACKUP_CODES_NOT_ENABLED">;
+            INVALID_BACKUP_CODE: import("better-auth").RawError<"INVALID_BACKUP_CODE">;
+            INVALID_CODE: import("better-auth").RawError<"INVALID_CODE">;
+            TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+            INVALID_TWO_FACTOR_COOKIE: import("better-auth").RawError<"INVALID_TWO_FACTOR_COOKIE">;
+        };
+    }, {
+        id: "username";
+        version: string;
+        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-call").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("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    $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;
+                };
+            }>;
+            isUsernameAvailable: import("better-call").StrictEndpoint<"/is-username-available", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    username: import("zod").ZodString;
+                }, import("zod/v4/core").$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 | Record<string, unknown> | unknown[] | null | undefined;
+                        };
+                    };
+                    displayUsername: {
+                        type: "string";
+                        required: false;
+                        transform: {
+                            input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
+                        };
+                    };
+                };
+            };
+        };
+        hooks: {
+            before: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        options: import("better-auth/plugins").UsernameOptions | undefined;
+        $ERROR_CODES: {
+            EMAIL_NOT_VERIFIED: import("better-auth").RawError<"EMAIL_NOT_VERIFIED">;
+            UNEXPECTED_ERROR: import("better-auth").RawError<"UNEXPECTED_ERROR">;
+            INVALID_USERNAME_OR_PASSWORD: import("better-auth").RawError<"INVALID_USERNAME_OR_PASSWORD">;
+            USERNAME_IS_ALREADY_TAKEN: import("better-auth").RawError<"USERNAME_IS_ALREADY_TAKEN">;
+            USERNAME_TOO_SHORT: import("better-auth").RawError<"USERNAME_TOO_SHORT">;
+            USERNAME_TOO_LONG: import("better-auth").RawError<"USERNAME_TOO_LONG">;
+            INVALID_USERNAME: import("better-auth").RawError<"INVALID_USERNAME">;
+            INVALID_DISPLAY_USERNAME: import("better-auth").RawError<"INVALID_DISPLAY_USERNAME">;
+        };
+    }, {
+        id: "phone-number";
+        version: string;
+        init(): {
+            options: {
+                databaseHooks: {
+                    user: {
+                        update: {
+                            before(data: Partial<{
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            }> & Record<string, unknown>): Promise<{
+                                data: {
+                                    [x: string]: unknown;
+                                    id?: string | undefined;
+                                    createdAt?: Date | undefined;
+                                    updatedAt?: Date | undefined;
+                                    email?: string | undefined;
+                                    emailVerified?: boolean | undefined;
+                                    name?: string | undefined;
+                                    image?: string | null | undefined;
+                                };
+                            } | undefined>;
+                        };
+                    };
+                };
+            };
+        };
+        hooks: {
+            before: {
+                matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<never>;
+            }[];
+        };
+        endpoints: {
+            signInPhoneNumber: import("better-call").StrictEndpoint<"/sign-in/phone-number", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    phoneNumber: import("zod").ZodString;
+                    password: import("zod").ZodString;
+                    rememberMe: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            400: {
+                                description: string;
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: import("better-auth/plugins").UserWithPhoneNumber;
+            }>;
+            sendPhoneNumberOTP: import("better-call").StrictEndpoint<"/phone-number/send-otp", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    phoneNumber: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                message: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                message: string;
+            }>;
+            verifyPhoneNumber: import("better-call").StrictEndpoint<"/phone-number/verify", {
+                method: "POST";
+                body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                    phoneNumber: import("zod").ZodString;
+                    code: import("zod").ZodString;
+                    disableSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    updatePhoneNumber: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                                token: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    properties: {
+                                                        id: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        email: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        emailVerified: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        name: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        image: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        phoneNumber: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        phoneNumberVerified: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        updatedAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            400: {
+                                description: string;
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & import("better-auth/plugins").UserWithPhoneNumber;
+            } | {
+                status: boolean;
+                token: null;
+                user: import("better-auth/plugins").UserWithPhoneNumber;
+            }>;
+            requestPasswordResetPhoneNumber: import("better-call").StrictEndpoint<"/phone-number/request-password-reset", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    phoneNumber: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            resetPasswordPhoneNumber: import("better-call").StrictEndpoint<"/phone-number/reset-password", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    otp: import("zod").ZodString;
+                    phoneNumber: import("zod").ZodString;
+                    newPassword: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+        };
+        schema: {
+            user: {
+                fields: {
+                    phoneNumber: {
+                        type: "string";
+                        required: false;
+                        unique: true;
+                        sortable: true;
+                        returned: true;
+                    };
+                    phoneNumberVerified: {
+                        type: "boolean";
+                        required: false;
+                        returned: true;
+                        input: false;
+                    };
+                };
+            };
+        };
+        rateLimit: {
+            pathMatcher(path: string): boolean;
+            window: number;
+            max: number;
+        }[];
+        options: import("better-auth/plugins").PhoneNumberOptions | undefined;
+        $ERROR_CODES: {
+            OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+            INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+            TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+            INVALID_PHONE_NUMBER: import("better-auth").RawError<"INVALID_PHONE_NUMBER">;
+            PHONE_NUMBER_EXIST: import("better-auth").RawError<"PHONE_NUMBER_EXIST">;
+            PHONE_NUMBER_NOT_EXIST: import("better-auth").RawError<"PHONE_NUMBER_NOT_EXIST">;
+            INVALID_PHONE_NUMBER_OR_PASSWORD: import("better-auth").RawError<"INVALID_PHONE_NUMBER_OR_PASSWORD">;
+            UNEXPECTED_ERROR: import("better-auth").RawError<"UNEXPECTED_ERROR">;
+            OTP_NOT_FOUND: import("better-auth").RawError<"OTP_NOT_FOUND">;
+            PHONE_NUMBER_NOT_VERIFIED: import("better-auth").RawError<"PHONE_NUMBER_NOT_VERIFIED">;
+            PHONE_NUMBER_CANNOT_BE_UPDATED: import("better-auth").RawError<"PHONE_NUMBER_CANNOT_BE_UPDATED">;
+            SEND_OTP_NOT_IMPLEMENTED: import("better-auth").RawError<"SEND_OTP_NOT_IMPLEMENTED">;
+        };
+    }, {
+        id: "magic-link";
+        version: string;
+        endpoints: {
+            signInMagicLink: import("better-call").StrictEndpoint<"/sign-in/magic-link", {
+                method: "POST";
+                requireHeaders: true;
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodEmail;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    newUserCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    errorCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            magicLinkVerify: import("better-call").StrictEndpoint<"/magic-link/verify", {
+                method: "GET";
+                query: import("zod").ZodObject<{
+                    token: import("zod").ZodString;
+                    callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    errorCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    newUserCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>)[];
+                requireHeaders: true;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                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;
+                };
+            }>;
+        };
+        rateLimit: {
+            pathMatcher(path: string): boolean;
+            window: number;
+            max: number;
+        }[];
+        options: import("better-auth/plugins").MagicLinkOptions;
+    }, {
+        id: "email-otp";
+        version: string;
+        init(ctx: import("better-auth").AuthContext): {
+            options: {
+                emailVerification: {
+                    sendVerificationEmail(data: {
+                        user: import("better-auth").User;
+                        url: string;
+                        token: string;
+                    }, request: Request | undefined): Promise<void>;
+                };
+            };
+        } | undefined;
+        endpoints: {
+            sendVerificationOTP: import("better-call").StrictEndpoint<"/email-otp/send-verification-otp", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
+                        "sign-in": "sign-in";
+                        "change-email": "change-email";
+                        "email-verification": "email-verification";
+                        "forget-password": "forget-password";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            createVerificationOTP: import("better-call").StrictEndpoint<string, {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
+                        "sign-in": "sign-in";
+                        "change-email": "change-email";
+                        "email-verification": "email-verification";
+                        "forget-password": "forget-password";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "string";
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, string>;
+            getVerificationOTP: import("better-call").StrictEndpoint<string, {
+                method: "GET";
+                query: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
+                        "sign-in": "sign-in";
+                        "change-email": "change-email";
+                        "email-verification": "email-verification";
+                        "forget-password": "forget-password";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                otp: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                otp: null;
+            } | {
+                otp: string;
+            }>;
+            checkVerificationOTP: import("better-call").StrictEndpoint<"/email-otp/check-verification-otp", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
+                        "sign-in": "sign-in";
+                        "change-email": "change-email";
+                        "email-verification": "email-verification";
+                        "forget-password": "forget-password";
+                    }>;
+                    otp: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            verifyEmailOTP: import("better-call").StrictEndpoint<"/email-otp/verify-email", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    otp: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                                token: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, any>;
+            } | {
+                status: boolean;
+                token: null;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, any>;
+            }>;
+            signInEmailOTP: import("better-call").StrictEndpoint<"/sign-in/email-otp", {
+                method: "POST";
+                body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    otp: import("zod").ZodString;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    image: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }>;
+            requestPasswordResetEmailOTP: import("better-call").StrictEndpoint<"/email-otp/request-password-reset", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            forgetPasswordEmailOTP: import("better-call").StrictEndpoint<"/forget-password/email-otp", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            resetPasswordEmailOTP: import("better-call").StrictEndpoint<"/email-otp/reset-password", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    otp: import("zod").ZodString;
+                    password: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            requestEmailChangeEmailOTP: import("better-call").StrictEndpoint<"/email-otp/request-email-change", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    newEmail: import("zod").ZodString;
+                    otp: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            changeEmailEmailOTP: import("better-call").StrictEndpoint<"/email-otp/change-email", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    newEmail: import("zod").ZodString;
+                    otp: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+        };
+        hooks: {
+            after: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        rateLimit: ({
+            pathMatcher(path: string): path is "/email-otp/send-verification-otp";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/check-verification-otp";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/verify-email";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/sign-in/email-otp";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/request-password-reset";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/reset-password";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/forget-password/email-otp";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/request-email-change";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/change-email";
+            window: number;
+            max: number;
+        })[];
+        options: import("better-auth/plugins").EmailOTPOptions;
+        $ERROR_CODES: {
+            OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+            INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+            TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+        };
+    }, {
+        id: "admin";
+        version: string;
+        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-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<import("better-auth/plugins").SessionWithImpersonatedBy[] | undefined>;
+            }[];
+        };
+        endpoints: {
+            setRole: import("better-call").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("zod/v4/core").$strip>;
+                requireHeaders: true;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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: "admin" | "authAdmin" | "authUser" | "superAdmin" | "user" | ("admin" | "authAdmin" | "authUser" | "superAdmin" | "user")[];
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins").UserWithRole;
+            }>;
+            getUser: import("better-call").StrictEndpoint<"/admin/get-user", {
+                method: "GET";
+                query: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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-call").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("zod/v4/core").$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?: "admin" | "authAdmin" | "authUser" | "superAdmin" | "user" | ("admin" | "authAdmin" | "authUser" | "superAdmin" | "user")[] | undefined;
+                            data?: Record<string, any> | undefined;
+                        };
+                    };
+                };
+            }, {
+                user: import("better-auth/plugins").UserWithRole;
+            }>;
+            adminUpdateUser: import("better-call").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("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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-call").StrictEndpoint<"/admin/list-users", {
+                method: "GET";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                query: import("zod").ZodObject<{
+                    searchValue: import("zod").ZodOptional<import("zod").ZodString>;
+                    searchField: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        email: "email";
+                        name: "name";
+                    }>>;
+                    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").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, import("zod").ZodBoolean]>, import("zod").ZodArray<import("zod").ZodString>]>, import("zod").ZodArray<import("zod").ZodNumber>]>>;
+                    filterOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        eq: "eq";
+                        ne: "ne";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        in: "in";
+                        not_in: "not_in";
+                        contains: "contains";
+                        starts_with: "starts_with";
+                        ends_with: "ends_with";
+                    }>>;
+                }, import("zod/v4/core").$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;
+            }>;
+            listUserSessions: import("better-call").StrictEndpoint<"/admin/list-user-sessions", {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$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-call").StrictEndpoint<"/admin/unban-user", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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-call").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("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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-call").StrictEndpoint<"/admin/impersonate-user", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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-call").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-call").StrictEndpoint<"/admin/revoke-user-session", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    sessionToken: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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-call").StrictEndpoint<"/admin/revoke-user-sessions", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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-call").StrictEndpoint<"/admin/remove-user", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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-call").StrictEndpoint<"/admin/set-user-password", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    newPassword: import("zod").ZodString;
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        user: import("better-auth/plugins").UserWithRole;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                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-call").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("zod/v4/core").$strip>, import("zod").ZodXor<readonly [import("zod").ZodObject<{
+                    permission: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    permissions: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>]>>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        requestBody: {
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            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: {
+                            permissions: {
+                                readonly user?: ("ban" | "create" | "delete" | "get" | "impersonate" | "impersonate-admins" | "list" | "set-password" | "set-role" | "update")[] | undefined;
+                                readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                                readonly 'asset_convert_product:product'?: ("create" | "list" | "read" | "update")[] | undefined;
+                                readonly 'asset_convert_product:order'?: ("list" | "read")[] | undefined;
+                                readonly 'asset_price:price'?: ("latest" | "list" | "read")[] | undefined;
+                                readonly 'asset_price:admin'?: ("create" | "latest" | "list" | "read")[] | undefined;
+                                readonly 'asset-type:type'?: ("create" | "list" | "read" | "update")[] | undefined;
+                                readonly 'asset:item'?: ("create" | "list" | "read" | "update")[] | undefined;
+                                readonly 'checkIn:checkIn'?: ("create" | "list" | "read")[] | undefined;
+                                readonly 'checkIn:admin'?: ("list" | "read")[] | undefined;
+                                readonly 'deposit:order'?: ("create" | "list" | "read" | "update")[] | undefined;
+                                readonly 'deposit:review'?: ("list" | "read" | "update")[] | undefined;
+                                readonly 'ledger_account:import'?: ("create" | "list" | "read")[] | undefined;
+                                readonly 'ledger-account:type'?: ("create" | "list" | "read" | "update")[] | undefined;
+                                readonly 'ledger-account:account'?: ("list" | "read" | "update")[] | undefined;
+                                readonly 'ledger:entry'?: ("adjust" | "list" | "read" | "view_all")[] | undefined;
+                                readonly 'market_data:ticker'?: ("latest" | "read")[] | undefined;
+                                readonly 'market_data:kline'?: ("list" | "read")[] | undefined;
+                                readonly 'market_data:admin'?: ("list" | "read" | "run")[] | undefined;
+                                readonly 'market_pricing:strategy'?: ("create" | "delete" | "list" | "read" | "run" | "update")[] | undefined;
+                                readonly 'news:category'?: ("create" | "delete" | "list" | "read" | "update")[] | undefined;
+                                readonly 'news:news'?: ("create" | "delete" | "list" | "read" | "update")[] | undefined;
+                                readonly 'notification:notification'?: ("list" | "read" | "update")[] | undefined;
+                                readonly 'notification:admin'?: ("create" | "list" | "read" | "stats")[] | undefined;
+                                readonly 'receipt_method:item'?: ("create" | "delete" | "list" | "read" | "update")[] | undefined;
+                                readonly 'referral:depth-config'?: ("create" | "delete" | "list" | "read" | "update")[] | undefined;
+                                readonly 'referral:relation'?: ("bind" | "list" | "read")[] | undefined;
+                                readonly 'shipping_address:item'?: ("create" | "delete" | "list" | "read" | "update")[] | undefined;
+                                readonly 'team:member'?: ("list" | "read" | "stats")[] | undefined;
+                                readonly 'trade_market:market'?: ("create" | "delete" | "list" | "read" | "update")[] | undefined;
+                                readonly 'trade_market:order'?: ("create" | "list" | "read")[] | undefined;
+                                readonly 'transfer:order'?: ("create" | "list" | "read")[] | undefined;
+                                readonly 'kyc:method'?: ("create" | "read" | "update")[] | undefined;
+                                readonly 'kyc:admin'?: ("approve" | "list" | "read" | "reject")[] | undefined;
+                                readonly 'user:profile'?: ("read" | "update")[] | undefined;
+                                readonly 'user:referral'?: "bind"[] | undefined;
+                                readonly 'admin:user-profile'?: ("list" | "read" | "update")[] | undefined;
+                                readonly 'wallet:type'?: ("create" | "delete" | "list" | "read" | "update")[] | undefined;
+                                readonly 'wallet:container'?: ("list" | "read")[] | undefined;
+                                readonly 'welfare_cycle:plan'?: ("create" | "delete" | "list" | "read" | "update")[] | undefined;
+                                readonly 'welfare_cycle:subscription'?: ("create" | "list" | "read")[] | undefined;
+                                readonly 'welfare_cycle:payout'?: ("create" | "list" | "read")[] | undefined;
+                                readonly 'withdraw:manage'?: ("create" | "read")[] | undefined;
+                                readonly 'withdraw:review'?: ("approve" | "paid" | "read" | "reject")[] | undefined;
+                            };
+                        } & {
+                            userId?: string | undefined;
+                            role?: "admin" | "authAdmin" | "authUser" | "superAdmin" | "user" | undefined;
+                        };
+                    };
+                };
+            }, {
+                error: null;
+                success: boolean;
+            }>;
+        };
+        $ERROR_CODES: {
+            USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: import("better-auth").RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+            FAILED_TO_CREATE_USER: import("better-auth").RawError<"FAILED_TO_CREATE_USER">;
+            USER_ALREADY_EXISTS: import("better-auth").RawError<"USER_ALREADY_EXISTS">;
+            YOU_CANNOT_BAN_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_BAN_YOURSELF">;
+            YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS">;
+            YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_BAN_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD">;
+            BANNED_USER: import("better-auth").RawError<"BANNED_USER">;
+            YOU_ARE_NOT_ALLOWED_TO_GET_USER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_USER">;
+            NO_DATA_TO_UPDATE: import("better-auth").RawError<"NO_DATA_TO_UPDATE">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS">;
+            YOU_CANNOT_REMOVE_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_REMOVE_YOURSELF">;
+            YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE">;
+            YOU_CANNOT_IMPERSONATE_ADMINS: import("better-auth").RawError<"YOU_CANNOT_IMPERSONATE_ADMINS">;
+            INVALID_ROLE_TYPE: import("better-auth").RawError<"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<{
+            ac: {
+                newRole<K extends "admin:user-profile" | "asset-type:type" | "asset:item" | "asset_convert_product:order" | "asset_convert_product:product" | "asset_price:admin" | "asset_price:price" | "checkIn:admin" | "checkIn:checkIn" | "deposit:order" | "deposit:review" | "kyc:admin" | "kyc:method" | "ledger-account:account" | "ledger-account:type" | "ledger:entry" | "ledger_account:import" | "market_data:admin" | "market_data:kline" | "market_data:ticker" | "market_pricing:strategy" | "news:category" | "news:news" | "notification:admin" | "notification:notification" | "receipt_method:item" | "referral:depth-config" | "referral:relation" | "session" | "shipping_address:item" | "team:member" | "trade_market:market" | "trade_market:order" | "transfer:order" | "user" | "user:profile" | "user:referral" | "wallet:container" | "wallet:type" | "welfare_cycle:payout" | "welfare_cycle:plan" | "welfare_cycle:subscription" | "withdraw:manage" | "withdraw:review">(statements: import("better-auth/plugins").Subset<K, {
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
+                    readonly session: readonly ["list", "revoke", "delete"];
+                    readonly 'asset_convert_product:product': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'asset_convert_product:order': readonly ['read', 'list'];
+                    readonly 'asset_price:price': readonly ['read', 'list', 'latest'];
+                    readonly 'asset_price:admin': readonly ['create', 'read', 'list', 'latest'];
+                    readonly 'asset-type:type': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'asset:item': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'checkIn:checkIn': readonly ['create', 'read', 'list'];
+                    readonly 'checkIn:admin': readonly ['read', 'list'];
+                    readonly 'deposit:order': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'deposit:review': readonly ['read', 'update', 'list'];
+                    readonly 'ledger_account:import': readonly ['create', 'read', 'list'];
+                    readonly 'ledger-account:type': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'ledger-account:account': readonly ['read', 'update', 'list'];
+                    readonly 'ledger:entry': readonly ['read', 'list', 'view_all', 'adjust'];
+                    readonly 'market_data:ticker': readonly ['read', 'latest'];
+                    readonly 'market_data:kline': readonly ['read', 'list'];
+                    readonly 'market_data:admin': readonly ['read', 'list', 'run'];
+                    readonly 'market_pricing:strategy': readonly ['create', 'read', 'update', 'delete', 'list', 'run'];
+                    readonly 'news:category': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'news:news': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'notification:notification': readonly ['read', 'update', 'list'];
+                    readonly 'notification:admin': readonly ['create', 'read', 'list', 'stats'];
+                    readonly 'receipt_method:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'referral:depth-config': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'referral:relation': readonly ['bind', 'read', 'list'];
+                    readonly 'shipping_address:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'team:member': readonly ['read', 'list', 'stats'];
+                    readonly 'trade_market:market': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'trade_market:order': readonly ['create', 'read', 'list'];
+                    readonly 'transfer:order': readonly ['create', 'read', 'list'];
+                    readonly 'kyc:method': readonly ['create', 'read', 'update'];
+                    readonly 'kyc:admin': readonly ['read', 'list', 'approve', 'reject'];
+                    readonly 'user:profile': readonly ['read', 'update'];
+                    readonly 'user:referral': readonly ['bind'];
+                    readonly 'admin:user-profile': readonly ['read', 'update', 'list'];
+                    readonly 'wallet:type': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'wallet:container': readonly ['read', 'list'];
+                    readonly 'welfare_cycle:plan': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'welfare_cycle:subscription': readonly ['create', 'read', 'list'];
+                    readonly 'welfare_cycle:payout': readonly ['create', 'read', 'list'];
+                    readonly 'withdraw:manage': readonly ['create', 'read'];
+                    readonly 'withdraw:review': readonly ['read', 'approve', 'reject', 'paid'];
+                }>): {
+                    authorize<K_1 extends K>(request: K_1 extends infer T extends K_2 ? { [key in T]?: {
+                        actions: import("better-auth/plugins").Subset<K, {
+                            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
+                            readonly session: readonly ["list", "revoke", "delete"];
+                            readonly 'asset_convert_product:product': readonly ['create', 'read', 'update', 'list'];
+                            readonly 'asset_convert_product:order': readonly ['read', 'list'];
+                            readonly 'asset_price:price': readonly ['read', 'list', 'latest'];
+                            readonly 'asset_price:admin': readonly ['create', 'read', 'list', 'latest'];
+                            readonly 'asset-type:type': readonly ['create', 'read', 'update', 'list'];
+                            readonly 'asset:item': readonly ['create', 'read', 'update', 'list'];
+                            readonly 'checkIn:checkIn': readonly ['create', 'read', 'list'];
+                            readonly 'checkIn:admin': readonly ['read', 'list'];
+                            readonly 'deposit:order': readonly ['create', 'read', 'update', 'list'];
+                            readonly 'deposit:review': readonly ['read', 'update', 'list'];
+                            readonly 'ledger_account:import': readonly ['create', 'read', 'list'];
+                            readonly 'ledger-account:type': readonly ['create', 'read', 'update', 'list'];
+                            readonly 'ledger-account:account': readonly ['read', 'update', 'list'];
+                            readonly 'ledger:entry': readonly ['read', 'list', 'view_all', 'adjust'];
+                            readonly 'market_data:ticker': readonly ['read', 'latest'];
+                            readonly 'market_data:kline': readonly ['read', 'list'];
+                            readonly 'market_data:admin': readonly ['read', 'list', 'run'];
+                            readonly 'market_pricing:strategy': readonly ['create', 'read', 'update', 'delete', 'list', 'run'];
+                            readonly 'news:category': readonly ['create', 'read', 'update', 'delete', 'list'];
+                            readonly 'news:news': readonly ['create', 'read', 'update', 'delete', 'list'];
+                            readonly 'notification:notification': readonly ['read', 'update', 'list'];
+                            readonly 'notification:admin': readonly ['create', 'read', 'list', 'stats'];
+                            readonly 'receipt_method:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                            readonly 'referral:depth-config': readonly ['create', 'read', 'update', 'delete', 'list'];
+                            readonly 'referral:relation': readonly ['bind', 'read', 'list'];
+                            readonly 'shipping_address:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                            readonly 'team:member': readonly ['read', 'list', 'stats'];
+                            readonly 'trade_market:market': readonly ['create', 'read', 'update', 'delete', 'list'];
+                            readonly 'trade_market:order': readonly ['create', 'read', 'list'];
+                            readonly 'transfer:order': readonly ['create', 'read', 'list'];
+                            readonly 'kyc:method': readonly ['create', 'read', 'update'];
+                            readonly 'kyc:admin': readonly ['read', 'list', 'approve', 'reject'];
+                            readonly 'user:profile': readonly ['read', 'update'];
+                            readonly 'user:referral': readonly ['bind'];
+                            readonly 'admin:user-profile': readonly ['read', 'update', 'list'];
+                            readonly 'wallet:type': readonly ['create', 'read', 'update', 'delete', 'list'];
+                            readonly 'wallet:container': readonly ['read', 'list'];
+                            readonly 'welfare_cycle:plan': readonly ['create', 'read', 'update', 'delete', 'list'];
+                            readonly 'welfare_cycle:subscription': readonly ['create', 'read', 'list'];
+                            readonly 'welfare_cycle:payout': readonly ['create', 'read', 'list'];
+                            readonly 'withdraw:manage': readonly ['create', 'read'];
+                            readonly 'withdraw:review': readonly ['read', 'approve', 'reject', 'paid'];
+                        }>[key];
+                        connector: "OR" | "AND";
+                    } | import("better-auth/plugins").Subset<K, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                        readonly 'asset_convert_product:product': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'asset_convert_product:order': readonly ['read', 'list'];
+                        readonly 'asset_price:price': readonly ['read', 'list', 'latest'];
+                        readonly 'asset_price:admin': readonly ['create', 'read', 'list', 'latest'];
+                        readonly 'asset-type:type': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'asset:item': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'checkIn:checkIn': readonly ['create', 'read', 'list'];
+                        readonly 'checkIn:admin': readonly ['read', 'list'];
+                        readonly 'deposit:order': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'deposit:review': readonly ['read', 'update', 'list'];
+                        readonly 'ledger_account:import': readonly ['create', 'read', 'list'];
+                        readonly 'ledger-account:type': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'ledger-account:account': readonly ['read', 'update', 'list'];
+                        readonly 'ledger:entry': readonly ['read', 'list', 'view_all', 'adjust'];
+                        readonly 'market_data:ticker': readonly ['read', 'latest'];
+                        readonly 'market_data:kline': readonly ['read', 'list'];
+                        readonly 'market_data:admin': readonly ['read', 'list', 'run'];
+                        readonly 'market_pricing:strategy': readonly ['create', 'read', 'update', 'delete', 'list', 'run'];
+                        readonly 'news:category': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'news:news': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'notification:notification': readonly ['read', 'update', 'list'];
+                        readonly 'notification:admin': readonly ['create', 'read', 'list', 'stats'];
+                        readonly 'receipt_method:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'referral:depth-config': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'referral:relation': readonly ['bind', 'read', 'list'];
+                        readonly 'shipping_address:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'team:member': readonly ['read', 'list', 'stats'];
+                        readonly 'trade_market:market': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'trade_market:order': readonly ['create', 'read', 'list'];
+                        readonly 'transfer:order': readonly ['create', 'read', 'list'];
+                        readonly 'kyc:method': readonly ['create', 'read', 'update'];
+                        readonly 'kyc:admin': readonly ['read', 'list', 'approve', 'reject'];
+                        readonly 'user:profile': readonly ['read', 'update'];
+                        readonly 'user:referral': readonly ['bind'];
+                        readonly 'admin:user-profile': readonly ['read', 'update', 'list'];
+                        readonly 'wallet:type': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'wallet:container': readonly ['read', 'list'];
+                        readonly 'welfare_cycle:plan': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'welfare_cycle:subscription': readonly ['create', 'read', 'list'];
+                        readonly 'welfare_cycle:payout': readonly ['create', 'read', 'list'];
+                        readonly 'withdraw:manage': readonly ['create', 'read'];
+                        readonly 'withdraw:review': readonly ['read', 'approve', 'reject', 'paid'];
+                    }>[key] | undefined; } : never, connector?: "OR" | "AND"): import("better-auth/plugins").AuthorizeResponse;
+                    statements: import("better-auth/plugins").Subset<K, {
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
+                        readonly session: readonly ["list", "revoke", "delete"];
+                        readonly 'asset_convert_product:product': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'asset_convert_product:order': readonly ['read', 'list'];
+                        readonly 'asset_price:price': readonly ['read', 'list', 'latest'];
+                        readonly 'asset_price:admin': readonly ['create', 'read', 'list', 'latest'];
+                        readonly 'asset-type:type': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'asset:item': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'checkIn:checkIn': readonly ['create', 'read', 'list'];
+                        readonly 'checkIn:admin': readonly ['read', 'list'];
+                        readonly 'deposit:order': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'deposit:review': readonly ['read', 'update', 'list'];
+                        readonly 'ledger_account:import': readonly ['create', 'read', 'list'];
+                        readonly 'ledger-account:type': readonly ['create', 'read', 'update', 'list'];
+                        readonly 'ledger-account:account': readonly ['read', 'update', 'list'];
+                        readonly 'ledger:entry': readonly ['read', 'list', 'view_all', 'adjust'];
+                        readonly 'market_data:ticker': readonly ['read', 'latest'];
+                        readonly 'market_data:kline': readonly ['read', 'list'];
+                        readonly 'market_data:admin': readonly ['read', 'list', 'run'];
+                        readonly 'market_pricing:strategy': readonly ['create', 'read', 'update', 'delete', 'list', 'run'];
+                        readonly 'news:category': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'news:news': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'notification:notification': readonly ['read', 'update', 'list'];
+                        readonly 'notification:admin': readonly ['create', 'read', 'list', 'stats'];
+                        readonly 'receipt_method:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'referral:depth-config': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'referral:relation': readonly ['bind', 'read', 'list'];
+                        readonly 'shipping_address:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'team:member': readonly ['read', 'list', 'stats'];
+                        readonly 'trade_market:market': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'trade_market:order': readonly ['create', 'read', 'list'];
+                        readonly 'transfer:order': readonly ['create', 'read', 'list'];
+                        readonly 'kyc:method': readonly ['create', 'read', 'update'];
+                        readonly 'kyc:admin': readonly ['read', 'list', 'approve', 'reject'];
+                        readonly 'user:profile': readonly ['read', 'update'];
+                        readonly 'user:referral': readonly ['bind'];
+                        readonly 'admin:user-profile': readonly ['read', 'update', 'list'];
+                        readonly 'wallet:type': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'wallet:container': readonly ['read', 'list'];
+                        readonly 'welfare_cycle:plan': readonly ['create', 'read', 'update', 'delete', 'list'];
+                        readonly 'welfare_cycle:subscription': readonly ['create', 'read', 'list'];
+                        readonly 'welfare_cycle:payout': readonly ['create', 'read', 'list'];
+                        readonly 'withdraw:manage': readonly ['create', 'read'];
+                        readonly 'withdraw:review': readonly ['read', 'approve', 'reject', 'paid'];
+                    }>;
+                };
+                statements: {
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
+                    readonly session: readonly ["list", "revoke", "delete"];
+                    readonly 'asset_convert_product:product': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'asset_convert_product:order': readonly ['read', 'list'];
+                    readonly 'asset_price:price': readonly ['read', 'list', 'latest'];
+                    readonly 'asset_price:admin': readonly ['create', 'read', 'list', 'latest'];
+                    readonly 'asset-type:type': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'asset:item': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'checkIn:checkIn': readonly ['create', 'read', 'list'];
+                    readonly 'checkIn:admin': readonly ['read', 'list'];
+                    readonly 'deposit:order': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'deposit:review': readonly ['read', 'update', 'list'];
+                    readonly 'ledger_account:import': readonly ['create', 'read', 'list'];
+                    readonly 'ledger-account:type': readonly ['create', 'read', 'update', 'list'];
+                    readonly 'ledger-account:account': readonly ['read', 'update', 'list'];
+                    readonly 'ledger:entry': readonly ['read', 'list', 'view_all', 'adjust'];
+                    readonly 'market_data:ticker': readonly ['read', 'latest'];
+                    readonly 'market_data:kline': readonly ['read', 'list'];
+                    readonly 'market_data:admin': readonly ['read', 'list', 'run'];
+                    readonly 'market_pricing:strategy': readonly ['create', 'read', 'update', 'delete', 'list', 'run'];
+                    readonly 'news:category': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'news:news': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'notification:notification': readonly ['read', 'update', 'list'];
+                    readonly 'notification:admin': readonly ['create', 'read', 'list', 'stats'];
+                    readonly 'receipt_method:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'referral:depth-config': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'referral:relation': readonly ['bind', 'read', 'list'];
+                    readonly 'shipping_address:item': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'team:member': readonly ['read', 'list', 'stats'];
+                    readonly 'trade_market:market': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'trade_market:order': readonly ['create', 'read', 'list'];
+                    readonly 'transfer:order': readonly ['create', 'read', 'list'];
+                    readonly 'kyc:method': readonly ['create', 'read', 'update'];
+                    readonly 'kyc:admin': readonly ['read', 'list', 'approve', 'reject'];
+                    readonly 'user:profile': readonly ['read', 'update'];
+                    readonly 'user:referral': readonly ['bind'];
+                    readonly 'admin:user-profile': readonly ['read', 'update', 'list'];
+                    readonly 'wallet:type': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'wallet:container': readonly ['read', 'list'];
+                    readonly 'welfare_cycle:plan': readonly ['create', 'read', 'update', 'delete', 'list'];
+                    readonly 'welfare_cycle:subscription': readonly ['create', 'read', 'list'];
+                    readonly 'welfare_cycle:payout': readonly ['create', 'read', 'list'];
+                    readonly 'withdraw:manage': readonly ['create', 'read'];
+                    readonly 'withdraw:review': readonly ['read', 'approve', 'reject', 'paid'];
+                };
+            };
+            roles: typeof roles;
+            defaultRole: string;
+            adminRoles: string[];
+        }>;
+    }, {
+        id: "last-login-method";
+        version: string;
+        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: {
+                                    lastLoginMethod: any;
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            } | undefined>;
+                        };
+                    };
+                    session: {
+                        create: {
+                            after(session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            } & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<void>;
+                        };
+                    };
+                };
+            };
+        };
+        hooks: {
+            after: {
+                matcher(): true;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        schema: undefined;
+        options: NoInfer<import("better-auth/plugins").LastLoginMethodOptions>;
+    }, {
+        id: "multi-session";
+        version: string;
+        endpoints: {
+            listDeviceSessions: import("better-call").StrictEndpoint<"/multi-session/list-device-sessions", {
+                method: "GET";
+                requireHeaders: true;
+            }, {
+                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;
+                };
+            }[]>;
+            setActiveSession: import("better-call").StrictEndpoint<"/multi-session/set-active", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    sessionToken: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                requireHeaders: true;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                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>;
+            }>;
+            revokeDeviceSession: import("better-call").StrictEndpoint<"/multi-session/revoke", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    sessionToken: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                requireHeaders: true;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+        };
+        hooks: {
+            after: {
+                matcher: (context: import("better-auth").HookEndpointContext) => boolean;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        options: import("better-auth/plugins").MultiSessionConfig | undefined;
+        $ERROR_CODES: {
+            INVALID_SESSION_TOKEN: import("better-auth").RawError<"INVALID_SESSION_TOKEN">;
+        };
+    }, {
+        id: "open-api";
+        version: string;
+        endpoints: {
+            generateOpenAPISchema: import("better-call").StrictEndpoint<"/open-api/generate-schema", {
+                method: "GET";
+            }, {
+                openapi: string;
+                info: {
+                    title: string;
+                    description: string;
+                    version: string;
+                };
+                components: {
+                    securitySchemes: {
+                        apiKeyCookie: {
+                            type: string;
+                            in: string;
+                            name: string;
+                            description: string;
+                        };
+                        bearerAuth: {
+                            type: string;
+                            scheme: string;
+                            description: string;
+                        };
+                    };
+                    schemas: {
+                        [x: string]: import("better-auth/plugins").OpenAPIModelSchema;
+                    };
+                };
+                security: {
+                    apiKeyCookie: never[];
+                    bearerAuth: never[];
+                }[];
+                servers: {
+                    url: string;
+                }[];
+                tags: {
+                    name: string;
+                    description: string;
+                }[];
+                paths: Record<string, import("better-auth/plugins").Path>;
+            }>;
+            openAPIReference: import("better-call").StrictEndpoint<import("better-auth").LiteralString | "/reference", {
+                method: "GET";
+                metadata: {
+                    readonly scope: "server";
+                };
+            }, Response>;
+        };
+        options: NoInfer<import("better-auth/plugins").OpenAPIOptions>;
+    }];
+}>;