better-auth 0.0.2-beta.7 → 0.0.2

package/dist/client-A2Mt04KQ.d.ts

@@ -0,0 +1,3503 @@
+import * as nanostores from 'nanostores';
+import { u as useAuthStore, a as useAuthStore$1, b as AuthProxySignal } from './type-DbMyI3b5.js';
+import { G as GenericEndpointContext } from './index-W5nXvJ-p.js';
+import { U as User, S as Session } from './schema-BOszzrbQ.js';
+import * as zod from 'zod';
+import { z, ZodObject, ZodOptional, ZodArray, ZodLiteral } from 'zod';
+import * as better_call from 'better-call';
+import { useAuthStore as useAuthStore$2 } from './preact.js';
+import * as _better_fetch_fetch from '@better-fetch/fetch';
+import { BetterFetch } from '@better-fetch/fetch';
+import { A as AccessControl, R as Role, S as StatementsPrimitive, g as defaultRoles } from './statement-COylZd3J.js';
+import * as _simplewebauthn_types from '@simplewebauthn/types';
+import { CredentialDeviceType, PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON } from '@simplewebauthn/types';
+
+interface BackupCodeOptions {
+    /**
+     * The amount of backup codes to generate
+     *
+     * @default 10
+     */
+    amount?: number;
+    /**
+     * The length of the backup codes
+     *
+     * @default 10
+     */
+    length?: number;
+    customBackupCodesGenerate?: () => string[];
+}
+
+interface OTPOptions {
+    /**
+     * How long the opt will be valid for
+     *
+     * @default "5 mins"
+     */
+    period?: number;
+    sendOTP: (user: UserWithTwoFactor, otp: string) => Promise<void>;
+}
+
+type TOTPOptions = {
+    /**
+     * Issuer
+     */
+    issuer: string;
+    /**
+     * How many digits the otp to be
+     *
+     * @default 6
+     */
+    digits?: 6 | 8;
+    /**
+     * Period for otp in seconds.
+     * @default 30
+     */
+    period?: number;
+    /**
+     * Backup codes configuration
+     */
+    backupCodes?: BackupCodeOptions;
+};
+
+interface TwoFactorOptions {
+    issuer: string;
+    totpOptions?: Omit<TOTPOptions, "issuer">;
+    otpOptions?: OTPOptions;
+    backupCodeOptions?: BackupCodeOptions;
+}
+interface UserWithTwoFactor extends User {
+    /**
+     * If the user has enabled two factor authentication.
+     */
+    twoFactorEnabled: boolean;
+    /**
+     * The secret used to generate the TOTP or OTP.
+     */
+    twoFactorSecret: string;
+    /**
+     * List of backup codes separated by a
+     * comma
+     */
+    twoFactorBackupCodes: string;
+}
+
+declare const twoFactorClient: (options?: {
+    twoFactorPage: string;
+    /**
+     * Redirect to the two factor page. If twoFactorPage
+     * is not set this will redirect to the root path.
+     * @default true
+     */
+    redirect?: boolean;
+}) => ($fetch: _better_fetch_fetch.BetterFetch) => {
+    integrations: {
+        react?: ((useStore: typeof useAuthStore) => Record<string, any>) | undefined;
+        vue?: ((useStore: typeof useAuthStore$1) => Record<string, any>) | undefined;
+        preact?: ((useStore: typeof useAuthStore$2) => Record<string, any>) | undefined;
+        svelte?: (() => Record<string, any>) | undefined;
+    };
+    plugin: {
+        id: "two-factor";
+        endpoints: {
+            enableTwoFactor: {
+                (ctx_0?: better_call.Context<"/two-factor/enable", {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }> | undefined): Promise<{
+                    status: boolean;
+                }>;
+                path: "/two-factor/enable";
+                options: {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            disableTwoFactor: {
+                (ctx_0?: better_call.Context<"/two-factor/disable", {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }> | undefined): Promise<{
+                    status: boolean;
+                }>;
+                path: "/two-factor/disable";
+                options: {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            verifyBackupCode: {
+                (ctx_0: better_call.Context<"/two-factor/verify-backup-code", {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        code: zod.ZodString;
+                    }, "strip", zod.ZodTypeAny, {
+                        code: string;
+                    }, {
+                        code: string;
+                    }>;
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        valid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        invalid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            user: UserWithTwoFactor;
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }>): Promise<{
+                    status: boolean;
+                }>;
+                path: "/two-factor/verify-backup-code";
+                options: {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        code: zod.ZodString;
+                    }, "strip", zod.ZodTypeAny, {
+                        code: string;
+                    }, {
+                        code: string;
+                    }>;
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        valid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        invalid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            user: UserWithTwoFactor;
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            generateBackupCodes: {
+                (ctx_0?: better_call.Context<"/two-factor/generate-backup-codes", {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }> | undefined): Promise<{
+                    status: boolean;
+                    backupCodes: string[];
+                }>;
+                path: "/two-factor/generate-backup-codes";
+                options: {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            viewBackupCodes: {
+                (ctx_0?: better_call.Context<"/view/backup-codes", {
+                    method: "GET";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }> | undefined): Promise<{
+                    status: boolean;
+                    backupCodes: Promise<string[] | null>;
+                }>;
+                path: "/view/backup-codes";
+                options: {
+                    method: "GET";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            send2FaOTP: {
+                (ctx_0?: better_call.Context<"/two-factor/send-otp", {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        valid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        invalid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            user: UserWithTwoFactor;
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }> | undefined): Promise<{
+                    status: boolean;
+                }>;
+                path: "/two-factor/send-otp";
+                options: {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        valid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        invalid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            user: UserWithTwoFactor;
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            verifyOTP: {
+                (ctx_0: better_call.Context<"/two-factor/verify-otp", {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        code: zod.ZodString;
+                    }, "strip", zod.ZodTypeAny, {
+                        code: string;
+                    }, {
+                        code: string;
+                    }>;
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        valid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        invalid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            user: UserWithTwoFactor;
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }>): Promise<{
+                    status: boolean;
+                }>;
+                path: "/two-factor/verify-otp";
+                options: {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        code: zod.ZodString;
+                    }, "strip", zod.ZodTypeAny, {
+                        code: string;
+                    }, {
+                        code: string;
+                    }>;
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        valid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        invalid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            user: UserWithTwoFactor;
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            generateTOTP: {
+                (ctx_0?: better_call.Context<"/totp/generate", {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }> | undefined): Promise<{
+                    code: string;
+                }>;
+                path: "/totp/generate";
+                options: {
+                    method: "POST";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            viewTOTPURI: {
+                (ctx_0?: better_call.Context<"/two-factor/get-totp-uri", {
+                    method: "GET";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }> | undefined): Promise<{
+                    totpURI: string;
+                }>;
+                path: "/two-factor/get-totp-uri";
+                options: {
+                    method: "GET";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            verifyTOTP: {
+                (ctx_0: better_call.Context<"/two-factor/verify-totp", {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        code: zod.ZodString;
+                        callbackURL: zod.ZodOptional<zod.ZodString>;
+                    }, "strip", zod.ZodTypeAny, {
+                        code: string;
+                        callbackURL?: string | undefined;
+                    }, {
+                        code: string;
+                        callbackURL?: string | undefined;
+                    }>;
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        valid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        invalid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            user: UserWithTwoFactor;
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }>): Promise<{
+                    status: boolean;
+                }>;
+                path: "/two-factor/verify-totp";
+                options: {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        code: zod.ZodString;
+                        callbackURL: zod.ZodOptional<zod.ZodString>;
+                    }, "strip", zod.ZodTypeAny, {
+                        code: string;
+                        callbackURL?: string | undefined;
+                    }, {
+                        code: string;
+                        callbackURL?: string | undefined;
+                    }>;
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        valid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        invalid: () => Promise<{
+                            response: {
+                                body: any;
+                                status: number;
+                                statusText: string;
+                                headers: Record<string, string> | undefined;
+                            };
+                            body: {
+                                status: boolean;
+                            };
+                            _flag: "json";
+                        }>;
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            user: UserWithTwoFactor;
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+        };
+        options: TwoFactorOptions;
+        hooks: {
+            after: {
+                matcher(context: GenericEndpointContext): boolean;
+                handler: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    response: Response;
+                } | undefined>, better_call.EndpointOptions>;
+            }[];
+        };
+        schema: {
+            user: {
+                fields: {
+                    twoFactorEnabled: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: false;
+                    };
+                    twoFactorSecret: {
+                        type: "string";
+                        required: false;
+                    };
+                    twoFactorBackupCodes: {
+                        type: "string";
+                        required: false;
+                        returned: false;
+                    };
+                };
+            };
+        };
+    };
+    id: string;
+    actions?: Record<string, any> | undefined;
+    authProxySignal?: AuthProxySignal[];
+    signals?: Record<string, nanostores.PreinitializedWritableAtom<boolean>>;
+    atoms?: Record<string, nanostores.Atom<any>>;
+    pathMethods?: Record<string, "POST" | "GET">;
+    fetchPlugins?: _better_fetch_fetch.BetterFetchPlugin[];
+};
+
+declare const memberSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+    organizationId: z.ZodString;
+    userId: z.ZodString;
+    role: z.ZodEnum<["admin", "member", "owner"]>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    userId: string;
+    name: string;
+    email: string;
+    organizationId: string;
+    role: "admin" | "member" | "owner";
+}, {
+    id: string;
+    userId: string;
+    name: string;
+    email: string;
+    organizationId: string;
+    role: "admin" | "member" | "owner";
+}>;
+declare const invitationSchema: z.ZodObject<{
+    id: z.ZodString;
+    organizationId: z.ZodString;
+    email: z.ZodString;
+    role: z.ZodEnum<["admin", "member", "owner"]>;
+    status: z.ZodDefault<z.ZodEnum<["pending", "accepted", "rejected", "canceled"]>>;
+    /**
+     * The id of the user who invited the user.
+     */
+    inviterId: z.ZodString;
+    expiresAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    expiresAt: Date;
+    status: "pending" | "accepted" | "rejected" | "canceled";
+    email: string;
+    organizationId: string;
+    role: "admin" | "member" | "owner";
+    inviterId: string;
+}, {
+    id: string;
+    expiresAt: Date;
+    email: string;
+    organizationId: string;
+    role: "admin" | "member" | "owner";
+    inviterId: string;
+    status?: "pending" | "accepted" | "rejected" | "canceled" | undefined;
+}>;
+type Member = z.infer<typeof memberSchema>;
+type Invitation = z.infer<typeof invitationSchema>;
+
+interface OrganizationOptions {
+    /**
+     * Configure whether new users are able to create new organizations.
+     * You can also pass a function that returns a boolean.
+     *
+     * 	@example
+     * ```ts
+     * allowUserToCreateOrganization: async (user) => {
+     * 		const plan = await getUserPlan(user);
+     *      return plan.name === "pro";
+     * }
+     * ```
+     * @default true
+     */
+    allowUserToCreateOrganization?: boolean | ((user: User) => Promise<boolean> | boolean);
+    /**
+     *
+     */
+    organizationLimit?: number;
+    /**
+     * The role that is assigned to the creator of the organization.
+     *
+     * @default "admin"
+     */
+    creatorRole?: "admin" | "owner";
+    /**
+     * The number of memberships a user can have in an organization.
+     *
+     * @default "unlimited"
+     */
+    membershipLimit?: number;
+    /**
+     * Configure the roles and permissions for the organization plugin.
+     *
+     */
+    ac?: AccessControl;
+    /**
+     *
+     */
+    roles?: {
+        [key in "admin" | "member" | "owner"]?: Role<any>;
+    };
+    /**
+     * The expiration time for the invitation link.
+     *
+     * @default 48 hours
+     */
+    invitationExpiresIn?: number;
+    /**
+     * @param invitation  the invitation object
+     * @param email  the email of the user to be invited
+     *
+     * Make sure to construct the invitation link using the invitation id.
+     * @example
+     * ```ts
+     * const invitationLink = `${ctx.origin}/organization/accept-invitation?invitationId=$
+     * {invitation.id}`
+     *
+     * ```
+     */
+    sendInvitationEmail?: (invitation: Invitation, email: string) => Promise<void>;
+}
+declare const organization: <O extends OrganizationOptions>(options?: O) => {
+    id: "organization";
+    endpoints: {
+        hasPermission: {
+            (ctx_0: better_call.Context<"/organization/has-permission", {
+                method: "POST";
+                requireHeaders: true;
+                body: ZodObject<{
+                    permission: ZodObject<{ [key in keyof (O["ac"] extends AccessControl<infer S extends StatementsPrimitive> ? S extends Record<string, any> ? S & {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    } : {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    } : {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    })]: ZodOptional<ZodArray<ZodLiteral<(O["ac"] extends AccessControl<infer S extends StatementsPrimitive> ? S extends Record<string, any> ? S & {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    } : {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    } : {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    })[key][number]>>>; }>;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>[];
+            }>): Promise<{
+                error: string;
+                success: boolean;
+            } | {
+                error: null;
+                success: boolean;
+            }>;
+            path: "/organization/has-permission";
+            options: {
+                method: "POST";
+                requireHeaders: true;
+                body: ZodObject<{
+                    permission: ZodObject<{ [key in keyof (O["ac"] extends AccessControl<infer S extends StatementsPrimitive> ? S extends Record<string, any> ? S & {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    } : {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    } : {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    })]: ZodOptional<ZodArray<ZodLiteral<(O["ac"] extends AccessControl<infer S extends StatementsPrimitive> ? S extends Record<string, any> ? S & {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    } : {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    } : {
+                        readonly organization: readonly ["update", "delete"];
+                        readonly member: readonly ["create", "update", "delete"];
+                        readonly invitation: readonly ["create", "cancel"];
+                    })[key][number]>>>; }>;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        createOrganization: {
+            (ctx_0: better_call.Context<"/organization/create", {
+                method: "POST";
+                body: ZodObject<{
+                    name: z.ZodString;
+                    slug: z.ZodString;
+                    userId: ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    slug: string;
+                    userId?: string | undefined;
+                }, {
+                    name: string;
+                    slug: string;
+                    userId?: string | undefined;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            }>): Promise<{
+                members: {
+                    id: string;
+                    userId: string;
+                    name: string;
+                    email: string;
+                    organizationId: string;
+                    role: "admin" | "member" | "owner";
+                }[];
+                id: string;
+                name: string;
+                slug: string;
+            } | null>;
+            path: "/organization/create";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    name: z.ZodString;
+                    slug: z.ZodString;
+                    userId: ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    slug: string;
+                    userId?: string | undefined;
+                }, {
+                    name: string;
+                    slug: string;
+                    userId?: string | undefined;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        updateOrganization: {
+            (ctx_0: better_call.Context<"/organization/update", {
+                method: "POST";
+                body: ZodObject<{
+                    name: ZodOptional<z.ZodString>;
+                    slug: ZodOptional<z.ZodString>;
+                    orgId: ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    name?: string | undefined;
+                    slug?: string | undefined;
+                    orgId?: string | undefined;
+                }, {
+                    name?: string | undefined;
+                    slug?: string | undefined;
+                    orgId?: string | undefined;
+                }>;
+                requireHeaders: true;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions>[];
+            }>): Promise<{
+                id: string;
+                name: string;
+                slug: string;
+            } | null>;
+            path: "/organization/update";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    name: ZodOptional<z.ZodString>;
+                    slug: ZodOptional<z.ZodString>;
+                    orgId: ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    name?: string | undefined;
+                    slug?: string | undefined;
+                    orgId?: string | undefined;
+                }, {
+                    name?: string | undefined;
+                    slug?: string | undefined;
+                    orgId?: string | undefined;
+                }>;
+                requireHeaders: true;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        setActiveOrganization: {
+            (ctx_0: better_call.Context<"/organization/set-active", {
+                method: "POST";
+                body: ZodObject<{
+                    orgId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    orgId: string;
+                }, {
+                    orgId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            ipAddress?: string | undefined;
+                            userAgent?: string | undefined;
+                        };
+                        user: {
+                            id: string;
+                            name: string;
+                            email: string;
+                            emailVerified: boolean;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            image?: string | undefined;
+                        };
+                    };
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions>)[];
+            }>): Promise<{
+                members: {
+                    id: string;
+                    userId: string;
+                    name: string;
+                    email: string;
+                    organizationId: string;
+                    role: "admin" | "member" | "owner";
+                }[];
+                invitations: {
+                    id: string;
+                    expiresAt: Date;
+                    status: "pending" | "accepted" | "rejected" | "canceled";
+                    email: string;
+                    organizationId: string;
+                    role: "admin" | "member" | "owner";
+                    inviterId: string;
+                }[];
+                id: string;
+                name: string;
+                slug: string;
+            } | null>;
+            path: "/organization/set-active";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    orgId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    orgId: string;
+                }, {
+                    orgId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            ipAddress?: string | undefined;
+                            userAgent?: string | undefined;
+                        };
+                        user: {
+                            id: string;
+                            name: string;
+                            email: string;
+                            emailVerified: boolean;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            image?: string | undefined;
+                        };
+                    };
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        getFullOrganization: {
+            (ctx_0: better_call.Context<"/organization/full", {
+                method: "GET";
+                query: ZodObject<{
+                    orgId: ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    orgId?: string | undefined;
+                }, {
+                    orgId?: string | undefined;
+                }>;
+                requireHeaders: true;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            }>): Promise<{
+                members: {
+                    id: string;
+                    userId: string;
+                    name: string;
+                    email: string;
+                    organizationId: string;
+                    role: "admin" | "member" | "owner";
+                }[];
+                invitations: {
+                    id: string;
+                    expiresAt: Date;
+                    status: "pending" | "accepted" | "rejected" | "canceled";
+                    email: string;
+                    organizationId: string;
+                    role: "admin" | "member" | "owner";
+                    inviterId: string;
+                }[];
+                id: string;
+                name: string;
+                slug: string;
+            } | null>;
+            path: "/organization/full";
+            options: {
+                method: "GET";
+                query: ZodObject<{
+                    orgId: ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    orgId?: string | undefined;
+                }, {
+                    orgId?: string | undefined;
+                }>;
+                requireHeaders: true;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        listOrganization: {
+            (ctx_0?: better_call.Context<"/organization/list", {
+                method: "GET";
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            }> | undefined): Promise<{
+                id: string;
+                name: string;
+                slug: string;
+            }[]>;
+            path: "/organization/list";
+            options: {
+                method: "GET";
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        createInvitation: {
+            (ctx_0: better_call.Context<"/organization/invite-member", {
+                method: "POST";
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+                body: ZodObject<{
+                    email: z.ZodString;
+                    role: z.ZodEnum<["admin", "member", "owner"]>;
+                    organizationId: ZodOptional<z.ZodString>;
+                    resend: ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    email: string;
+                    role: "admin" | "member" | "owner";
+                    organizationId?: string | undefined;
+                    resend?: boolean | undefined;
+                }, {
+                    email: string;
+                    role: "admin" | "member" | "owner";
+                    organizationId?: string | undefined;
+                    resend?: boolean | undefined;
+                }>;
+            }>): Promise<{
+                id: string;
+                expiresAt: Date;
+                status: "pending" | "accepted" | "rejected" | "canceled";
+                email: string;
+                organizationId: string;
+                role: "admin" | "member" | "owner";
+                inviterId: string;
+            } | null>;
+            path: "/organization/invite-member";
+            options: {
+                method: "POST";
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+                body: ZodObject<{
+                    email: z.ZodString;
+                    role: z.ZodEnum<["admin", "member", "owner"]>;
+                    organizationId: ZodOptional<z.ZodString>;
+                    resend: ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    email: string;
+                    role: "admin" | "member" | "owner";
+                    organizationId?: string | undefined;
+                    resend?: boolean | undefined;
+                }, {
+                    email: string;
+                    role: "admin" | "member" | "owner";
+                    organizationId?: string | undefined;
+                    resend?: boolean | undefined;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        cancelInvitation: {
+            (ctx_0: better_call.Context<"/organization/cancel-invitation", {
+                method: "POST";
+                body: ZodObject<{
+                    invitationId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    invitationId: string;
+                }, {
+                    invitationId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            }>): Promise<{
+                id: string;
+                expiresAt: Date;
+                status: "pending" | "accepted" | "rejected" | "canceled";
+                email: string;
+                organizationId: string;
+                role: "admin" | "member" | "owner";
+                inviterId: string;
+            } | null>;
+            path: "/organization/cancel-invitation";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    invitationId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    invitationId: string;
+                }, {
+                    invitationId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        acceptInvitation: {
+            (ctx_0: better_call.Context<"/organization/accept-invitation", {
+                method: "POST";
+                body: ZodObject<{
+                    invitationId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    invitationId: string;
+                }, {
+                    invitationId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            }>): Promise<{
+                invitation: {
+                    id: string;
+                    expiresAt: Date;
+                    status: "pending" | "accepted" | "rejected" | "canceled";
+                    email: string;
+                    organizationId: string;
+                    role: "admin" | "member" | "owner";
+                    inviterId: string;
+                };
+                member: {
+                    id: string;
+                    userId: string;
+                    name: string;
+                    email: string;
+                    organizationId: string;
+                    role: "admin" | "member" | "owner";
+                };
+            } | null>;
+            path: "/organization/accept-invitation";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    invitationId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    invitationId: string;
+                }, {
+                    invitationId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        getActiveInvitation: {
+            (ctx_0: better_call.Context<"/organization/get-active-invitation", {
+                method: "GET";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions>[];
+                query: ZodObject<{
+                    id: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                }, {
+                    id: string;
+                }>;
+            }>): Promise<{
+                organizationName: string;
+                organizationSlug: string;
+                inviterEmail: string;
+                inviterName: string;
+                id: string;
+                expiresAt: Date;
+                status: "pending" | "accepted" | "rejected" | "canceled";
+                email: string;
+                organizationId: string;
+                role: "admin" | "member" | "owner";
+                inviterId: string;
+            } | null>;
+            path: "/organization/get-active-invitation";
+            options: {
+                method: "GET";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions>[];
+                query: ZodObject<{
+                    id: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    id: string;
+                }, {
+                    id: string;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        rejectInvitation: {
+            (ctx_0: better_call.Context<"/organization/reject-invitation", {
+                method: "POST";
+                body: ZodObject<{
+                    invitationId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    invitationId: string;
+                }, {
+                    invitationId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            }>): Promise<{
+                invitation: {
+                    id: string;
+                    expiresAt: Date;
+                    status: "pending" | "accepted" | "rejected" | "canceled";
+                    email: string;
+                    organizationId: string;
+                    role: "admin" | "member" | "owner";
+                    inviterId: string;
+                };
+                member: null;
+            } | null>;
+            path: "/organization/reject-invitation";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    invitationId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    invitationId: string;
+                }, {
+                    invitationId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        removeMember: {
+            (ctx_0: better_call.Context<"/organization/remove-member", {
+                method: "POST";
+                body: ZodObject<{
+                    memberId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    memberId: string;
+                }, {
+                    memberId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            }>): Promise<void | null>;
+            path: "/organization/remove-member";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    memberId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    memberId: string;
+                }, {
+                    memberId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        updateMember: {
+            (ctx_0: better_call.Context<"/organization/update-member", {
+                method: "POST";
+                body: ZodObject<{
+                    memberId: z.ZodString;
+                    role: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    role: string;
+                    memberId: string;
+                }, {
+                    role: string;
+                    memberId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            }>): Promise<{
+                id: string;
+                userId: string;
+                name: string;
+                email: string;
+                organizationId: string;
+                role: "admin" | "member" | "owner";
+            } | null>;
+            path: "/organization/update-member";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    memberId: z.ZodString;
+                    role: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    role: string;
+                    memberId: string;
+                }, {
+                    role: string;
+                    memberId: string;
+                }>;
+                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    orgOptions: OrganizationOptions;
+                    roles: typeof defaultRoles & {
+                        [key: string]: Role<{}>;
+                    };
+                    getSession: (context: better_call.Context<any, any>) => Promise<{
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                } & {
+                    method: "*";
+                }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+    };
+    schema: {
+        session: {
+            fields: {
+                activeOrganizationId: {
+                    type: "string";
+                    required: false;
+                };
+            };
+        };
+        organization: {
+            fields: {
+                name: {
+                    type: "string";
+                };
+                slug: {
+                    type: "string";
+                    unique: true;
+                };
+            };
+        };
+        member: {
+            fields: {
+                organizationId: {
+                    type: "string";
+                    required: true;
+                };
+                userId: {
+                    type: "string";
+                    required: true;
+                };
+                email: {
+                    type: "string";
+                    required: true;
+                };
+                name: {
+                    type: "string";
+                };
+                role: {
+                    type: "string";
+                    required: true;
+                    defaultValue: string;
+                };
+            };
+        };
+        invitation: {
+            fields: {
+                organizationId: {
+                    type: "string";
+                    required: true;
+                };
+                email: {
+                    type: "string";
+                    required: true;
+                };
+                role: {
+                    type: "string";
+                    required: false;
+                };
+                status: {
+                    type: "string";
+                    required: true;
+                    defaultValue: string;
+                };
+                expiresAt: {
+                    type: "date";
+                    required: true;
+                };
+                inviterId: {
+                    type: "string";
+                    references: {
+                        model: string;
+                        field: string;
+                    };
+                };
+            };
+        };
+    };
+};
+
+interface PasskeyOptions {
+    /**
+     * A unique identifier for your website. 'localhost' is okay for
+     * local dev
+     */
+    rpID: string;
+    /**
+     * Human-readable title for your website
+     */
+    rpName: string;
+    /**
+     * The URL at which registrations and authentications should occur.
+     * 'http://localhost' and 'http://localhost:PORT' are also valid.
+     * Do NOT include any trailing /
+     *
+     * if this isn't provided. The client itself will
+     * pass this value.
+     */
+    origin?: string | null;
+    /**
+     * Advanced options
+     */
+    advanced?: {
+        webAuthnChallengeCookie?: string;
+    };
+}
+type WebAuthnCookieType = {
+    expectedChallenge: string;
+    userData: {
+        id: string;
+        email: string;
+    };
+    callbackURL?: string;
+};
+type Passkey = {
+    id: string;
+    publicKey: string;
+    userId: string;
+    webauthnUserID: string;
+    counter: number;
+    deviceType: CredentialDeviceType;
+    backedUp: boolean;
+    transports?: string;
+    createdAt: Date;
+};
+declare const passkey: (options: PasskeyOptions) => {
+    id: "passkey";
+    endpoints: {
+        generatePasskeyRegistrationOptions: {
+            (ctx_0?: better_call.Context<"/passkey/generate-register-options", {
+                method: "GET";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            ipAddress?: string | undefined;
+                            userAgent?: string | undefined;
+                        };
+                        user: {
+                            id: string;
+                            name: string;
+                            email: string;
+                            emailVerified: boolean;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            image?: string | undefined;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+                metadata: {
+                    client: boolean;
+                };
+            }> | undefined): Promise<PublicKeyCredentialCreationOptionsJSON>;
+            path: "/passkey/generate-register-options";
+            options: {
+                method: "GET";
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            ipAddress?: string | undefined;
+                            userAgent?: string | undefined;
+                        };
+                        user: {
+                            id: string;
+                            name: string;
+                            email: string;
+                            emailVerified: boolean;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            image?: string | undefined;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+                metadata: {
+                    client: boolean;
+                };
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        generatePasskeyAuthenticationOptions: {
+            (ctx_0?: better_call.Context<"/passkey/generate-authenticate-options", {
+                method: "POST";
+                body: z.ZodOptional<z.ZodObject<{
+                    email: z.ZodOptional<z.ZodString>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    email?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    email?: string | undefined;
+                    callbackURL?: string | undefined;
+                }>>;
+            }> | undefined): Promise<_simplewebauthn_types.PublicKeyCredentialRequestOptionsJSON>;
+            path: "/passkey/generate-authenticate-options";
+            options: {
+                method: "POST";
+                body: z.ZodOptional<z.ZodObject<{
+                    email: z.ZodOptional<z.ZodString>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    email?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    email?: string | undefined;
+                    callbackURL?: string | undefined;
+                }>>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        verifyPasskeyRegistration: {
+            (ctx_0: better_call.Context<"/passkey/verify-registration", {
+                method: "POST";
+                body: z.ZodObject<{
+                    response: z.ZodAny;
+                }, "strip", z.ZodTypeAny, {
+                    response?: any;
+                }, {
+                    response?: any;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            ipAddress?: string | undefined;
+                            userAgent?: string | undefined;
+                        };
+                        user: {
+                            id: string;
+                            name: string;
+                            email: string;
+                            emailVerified: boolean;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            image?: string | undefined;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            }>): Promise<Passkey | null>;
+            path: "/passkey/verify-registration";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    response: z.ZodAny;
+                }, "strip", z.ZodTypeAny, {
+                    response?: any;
+                }, {
+                    response?: any;
+                }>;
+                use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    session: {
+                        session: {
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            ipAddress?: string | undefined;
+                            userAgent?: string | undefined;
+                        };
+                        user: {
+                            id: string;
+                            name: string;
+                            email: string;
+                            emailVerified: boolean;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            image?: string | undefined;
+                        };
+                    };
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        verifyPasskeyAuthentication: {
+            (ctx_0: better_call.Context<"/passkey/verify-authentication", {
+                method: "POST";
+                body: z.ZodObject<{
+                    response: z.ZodAny;
+                }, "strip", z.ZodTypeAny, {
+                    response?: any;
+                }, {
+                    response?: any;
+                }>;
+            }>): Promise<{
+                session: {
+                    id: string;
+                    userId: string;
+                    expiresAt: Date;
+                    ipAddress?: string | undefined;
+                    userAgent?: string | undefined;
+                };
+            } | null>;
+            path: "/passkey/verify-authentication";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    response: z.ZodAny;
+                }, "strip", z.ZodTypeAny, {
+                    response?: any;
+                }, {
+                    response?: any;
+                }>;
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+    };
+    schema: {
+        passkey: {
+            fields: {
+                publicKey: {
+                    type: "string";
+                };
+                userId: {
+                    type: "string";
+                    references: {
+                        model: string;
+                        field: string;
+                    };
+                };
+                webauthnUserID: {
+                    type: "string";
+                };
+                counter: {
+                    type: "number";
+                };
+                deviceType: {
+                    type: "string";
+                };
+                backedUp: {
+                    type: "boolean";
+                };
+                transports: {
+                    type: "string";
+                    required: false;
+                };
+                createdAt: {
+                    type: "date";
+                    defaultValue: Date;
+                    required: false;
+                };
+            };
+        };
+    };
+};
+
+declare const getPasskeyActions: ($fetch: BetterFetch) => {
+    signInPasskey: (opts?: {
+        autoFill?: boolean;
+        email?: string;
+        callbackURL?: string;
+    }) => Promise<{
+        data: null;
+        error: {
+            message?: string | undefined;
+            status: number;
+            statusText: string;
+        };
+    } | undefined>;
+    registerPasskey: () => Promise<{
+        data: null;
+        error: {
+            message?: string | undefined;
+            status: number;
+            statusText: string;
+        };
+    } | undefined>;
+};
+declare const passkeyClient: ($fetch: BetterFetch) => {
+    integrations: {
+        react?: ((useStore: typeof useAuthStore) => Record<string, any>) | undefined;
+        vue?: ((useStore: typeof useAuthStore$1) => Record<string, any>) | undefined;
+        preact?: ((useStore: typeof useAuthStore$2) => Record<string, any>) | undefined;
+        svelte?: (() => Record<string, any>) | undefined;
+    };
+    plugin: {
+        id: "passkey";
+        endpoints: {
+            generatePasskeyRegistrationOptions: {
+                (ctx_0?: better_call.Context<"/passkey/generate-register-options", {
+                    method: "GET";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                    metadata: {
+                        client: boolean;
+                    };
+                }> | undefined): Promise<PublicKeyCredentialCreationOptionsJSON>;
+                path: "/passkey/generate-register-options";
+                options: {
+                    method: "GET";
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                    metadata: {
+                        client: boolean;
+                    };
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            generatePasskeyAuthenticationOptions: {
+                (ctx_0?: better_call.Context<"/passkey/generate-authenticate-options", {
+                    method: "POST";
+                    body: zod.ZodOptional<zod.ZodObject<{
+                        email: zod.ZodOptional<zod.ZodString>;
+                        callbackURL: zod.ZodOptional<zod.ZodString>;
+                    }, "strip", zod.ZodTypeAny, {
+                        email?: string | undefined;
+                        callbackURL?: string | undefined;
+                    }, {
+                        email?: string | undefined;
+                        callbackURL?: string | undefined;
+                    }>>;
+                }> | undefined): Promise<PublicKeyCredentialRequestOptionsJSON>;
+                path: "/passkey/generate-authenticate-options";
+                options: {
+                    method: "POST";
+                    body: zod.ZodOptional<zod.ZodObject<{
+                        email: zod.ZodOptional<zod.ZodString>;
+                        callbackURL: zod.ZodOptional<zod.ZodString>;
+                    }, "strip", zod.ZodTypeAny, {
+                        email?: string | undefined;
+                        callbackURL?: string | undefined;
+                    }, {
+                        email?: string | undefined;
+                        callbackURL?: string | undefined;
+                    }>>;
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            verifyPasskeyRegistration: {
+                (ctx_0: better_call.Context<"/passkey/verify-registration", {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        response: zod.ZodAny;
+                    }, "strip", zod.ZodTypeAny, {
+                        response?: any;
+                    }, {
+                        response?: any;
+                    }>;
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                }>): Promise<Passkey | null>;
+                path: "/passkey/verify-registration";
+                options: {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        response: zod.ZodAny;
+                    }, "strip", zod.ZodTypeAny, {
+                        response?: any;
+                    }, {
+                        response?: any;
+                    }>;
+                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                        session: {
+                            session: {
+                                id: string;
+                                userId: string;
+                                expiresAt: Date;
+                                ipAddress?: string | undefined;
+                                userAgent?: string | undefined;
+                            };
+                            user: {
+                                id: string;
+                                name: string;
+                                email: string;
+                                emailVerified: boolean;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                image?: string | undefined;
+                            };
+                        };
+                    }>, better_call.EndpointOptions>[];
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+            verifyPasskeyAuthentication: {
+                (ctx_0: better_call.Context<"/passkey/verify-authentication", {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        response: zod.ZodAny;
+                    }, "strip", zod.ZodTypeAny, {
+                        response?: any;
+                    }, {
+                        response?: any;
+                    }>;
+                }>): Promise<{
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        ipAddress?: string | undefined;
+                        userAgent?: string | undefined;
+                    };
+                } | null>;
+                path: "/passkey/verify-authentication";
+                options: {
+                    method: "POST";
+                    body: zod.ZodObject<{
+                        response: zod.ZodAny;
+                    }, "strip", zod.ZodTypeAny, {
+                        response?: any;
+                    }, {
+                        response?: any;
+                    }>;
+                };
+                method: better_call.Method | better_call.Method[];
+                headers: Headers;
+            };
+        };
+        schema: {
+            passkey: {
+                fields: {
+                    publicKey: {
+                        type: "string";
+                    };
+                    userId: {
+                        type: "string";
+                        references: {
+                            model: string;
+                            field: string;
+                        };
+                    };
+                    webauthnUserID: {
+                        type: "string";
+                    };
+                    counter: {
+                        type: "number";
+                    };
+                    deviceType: {
+                        type: "string";
+                    };
+                    backedUp: {
+                        type: "boolean";
+                    };
+                    transports: {
+                        type: "string";
+                        required: false;
+                    };
+                    createdAt: {
+                        type: "date";
+                        defaultValue: Date;
+                        required: false;
+                    };
+                };
+            };
+        };
+    };
+    id: string;
+    actions?: {
+        signInPasskey: (opts?: {
+            autoFill?: boolean;
+            email?: string;
+            callbackURL?: string;
+        }) => Promise<{
+            data: null;
+            error: {
+                message?: string | undefined;
+                status: number;
+                statusText: string;
+            };
+        } | undefined>;
+        registerPasskey: () => Promise<{
+            data: null;
+            error: {
+                message?: string | undefined;
+                status: number;
+                statusText: string;
+            };
+        } | undefined>;
+    } | undefined;
+    authProxySignal?: AuthProxySignal[];
+    signals?: Record<string, nanostores.PreinitializedWritableAtom<boolean>>;
+    atoms?: Record<string, nanostores.Atom<any>>;
+    pathMethods?: Record<string, "POST" | "GET">;
+    fetchPlugins?: _better_fetch_fetch.BetterFetchPlugin[];
+};
+
+export { type Invitation as I, type Member as M, type OrganizationOptions as O, type PasskeyOptions as P, type TwoFactorOptions as T, type UserWithTwoFactor as U, type WebAuthnCookieType as W, type Passkey as a, passkey as b, getPasskeyActions as g, organization as o, passkeyClient as p, twoFactorClient as t };