better-auth 0.0.8-beta.2 → 0.0.8-beta.21

package/dist/{client-CaF9eUcv.d.ts → index-Dwhjsk4l.d.ts}

@@ -1,108 +1,163 @@
-import * as nanostores from 'nanostores';
-import { u as useAuthStore, a as useAuthStore$1, b as AuthProxySignal } from './type-tYx_kmry.js';
-import { G as GenericEndpointContext } from './index-CGeV0d2g.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 { U as User, S as Session } from './index-CcxejJTH.js';
 import * as better_call from 'better-call';
-import { useAuthStore as useAuthStore$2 } from './preact.js';
+import { A as AccessControl, R as Role, S as StatementsPrimitive, g as defaultRoles } from './statement-D6SPoYOh.js';
+import { z, ZodObject, ZodOptional, ZodArray, ZodLiteral } from 'zod';
 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 { H as HookEndpointContext } from './internal-adapter-CVKQ4XR9.js';
 import * as _simplewebauthn_types from '@simplewebauthn/types';
-import { CredentialDeviceType, PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON } from '@simplewebauthn/types';
+import { CredentialDeviceType, PublicKeyCredentialCreationOptionsJSON } from '@simplewebauthn/types';
 
-interface BackupCodeOptions {
-    /**
-     * The amount of backup codes to generate
-     *
-     * @default 10
-     */
-    amount?: number;
+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: "member" | "admin" | "owner";
+}, {
+    id: string;
+    userId: string;
+    name: string;
+    email: string;
+    organizationId: string;
+    role: "member" | "admin" | "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 length of the backup codes
-     *
-     * @default 10
+     * The id of the user who invited the user.
      */
-    length?: number;
-    customBackupCodesGenerate?: () => string[];
-}
+    inviterId: z.ZodString;
+    expiresAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    expiresAt: Date;
+    status: "pending" | "accepted" | "rejected" | "canceled";
+    email: string;
+    organizationId: string;
+    role: "member" | "admin" | "owner";
+    inviterId: string;
+}, {
+    id: string;
+    expiresAt: Date;
+    email: string;
+    organizationId: string;
+    role: "member" | "admin" | "owner";
+    inviterId: string;
+    status?: "pending" | "accepted" | "rejected" | "canceled" | undefined;
+}>;
+type Member = z.infer<typeof memberSchema>;
+type Invitation = z.infer<typeof invitationSchema>;
 
-interface OTPOptions {
+interface OrganizationOptions {
     /**
-     * How long the opt will be valid for
+     * Configure whether new users are able to create new organizations.
+     * You can also pass a function that returns a boolean.
      *
-     * @default "5 mins"
+     * 	@example
+     * ```ts
+     * allowUserToCreateOrganization: async (user) => {
+     * 		const plan = await getUserPlan(user);
+     *      return plan.name === "pro";
+     * }
+     * ```
+     * @default true
      */
-    period?: number;
-    sendOTP: (user: UserWithTwoFactor, otp: string) => Promise<void>;
-}
-
-type TOTPOptions = {
+    allowUserToCreateOrganization?: boolean | ((user: User) => Promise<boolean> | boolean);
     /**
-     * Issuer
+     *
      */
-    issuer: string;
+    organizationLimit?: number;
     /**
-     * How many digits the otp to be
+     * The role that is assigned to the creator of the organization.
      *
-     * @default 6
+     * @default "admin"
      */
-    digits?: 6 | 8;
+    creatorRole?: "admin" | "owner";
     /**
-     * Period for otp in seconds.
-     * @default 30
+     * The number of memberships a user can have in an organization.
+     *
+     * @default "unlimited"
      */
-    period?: number;
+    membershipLimit?: number;
     /**
-     * Backup codes configuration
+     * Configure the roles and permissions for the organization plugin.
+     *
      */
-    backupCodes?: BackupCodeOptions;
-};
-
-interface TwoFactorOptions {
-    issuer: string;
-    totpOptions?: Omit<TOTPOptions, "issuer">;
-    otpOptions?: OTPOptions;
-    backupCodeOptions?: BackupCodeOptions;
-}
-interface UserWithTwoFactor extends User {
+    ac?: AccessControl;
     /**
-     * If the user has enabled two factor authentication.
+     *
      */
-    twoFactorEnabled: boolean;
+    roles?: {
+        [key in "admin" | "member" | "owner"]?: Role<any>;
+    };
     /**
-     * The secret used to generate the TOTP or OTP.
+     * The expiration time for the invitation link.
+     *
+     * @default 48 hours
      */
-    twoFactorSecret: string;
+    invitationExpiresIn?: number;
     /**
-     * List of backup codes separated by a
-     * comma
+     * @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}`
+     *
+     * ```
      */
-    twoFactorBackupCodes: string;
+    sendInvitationEmail?: (invitation: Invitation, email: string) => Promise<void>;
 }
-
-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";
+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: {
@@ -123,12 +178,16 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                }> | undefined): Promise<{
-                    status: boolean;
-                }>;
-                path: "/two-factor/enable";
-                options: {
-                    method: "POST";
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
                     use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                         session: {
                             session: {
@@ -149,13 +208,48 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                };
-                method: better_call.Method | better_call.Method[];
-                headers: Headers;
-            };
-            disableTwoFactor: {
-                (ctx_0?: better_call.Context<"/two-factor/disable", {
-                    method: "POST";
+                } & {
+                    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: {
@@ -176,12 +270,16 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                }> | undefined): Promise<{
-                    status: boolean;
-                }>;
-                path: "/two-factor/disable";
-                options: {
-                    method: "POST";
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
                     use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                         session: {
                             session: {
@@ -202,104 +300,41 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                };
-                method: better_call.Method | better_call.Method[];
-                headers: Headers;
+                } & {
+                    method: "*";
+                }>[];
             };
-            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;
+            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;
                 }>;
-                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;
+                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;
                         };
-                    }>, 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";
+                        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: {
@@ -320,13 +355,16 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                }> | undefined): Promise<{
-                    status: boolean;
-                    backupCodes: string[];
-                }>;
-                path: "/two-factor/generate-backup-codes";
-                options: {
-                    method: "POST";
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
                     use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                         session: {
                             session: {
@@ -347,13 +385,50 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                };
-                method: better_call.Method | better_call.Method[];
-                headers: Headers;
-            };
-            viewBackupCodes: {
-                (ctx_0?: better_call.Context<"/view/backup-codes", {
-                    method: "GET";
+                } & {
+                    method: "*";
+                }>)[];
+            }>): Promise<{
+                members: {
+                    id: string;
+                    userId: string;
+                    name: string;
+                    email: string;
+                    organizationId: string;
+                    role: "member" | "admin" | "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: {
@@ -374,13 +449,16 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                }> | undefined): Promise<{
-                    status: boolean;
-                    backupCodes: Promise<string[] | null>;
-                }>;
-                path: "/view/backup-codes";
-                options: {
-                    method: "GET";
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
                     use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                         session: {
                             session: {
@@ -401,181 +479,286 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                };
-                method: better_call.Method | better_call.Method[];
-                headers: Headers;
+                } & {
+                    method: "*";
+                }>)[];
             };
-            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;
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        updateOrganization: {
+            (ctx_0: better_call.Context<"/organization/update", {
+                method: "POST";
+                body: ZodObject<{
+                    data: ZodObject<{
+                        name: ZodOptional<ZodOptional<z.ZodString>>;
+                        slug: ZodOptional<ZodOptional<z.ZodString>>;
+                    }, "strip", z.ZodTypeAny, {
+                        name?: string | undefined;
+                        slug?: string | undefined;
+                    }, {
+                        name?: string | undefined;
+                        slug?: string | undefined;
+                    }>;
+                    orgId: ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    data: {
+                        name?: string | undefined;
+                        slug?: string | undefined;
+                    };
+                    orgId?: string | undefined;
+                }, {
+                    data: {
+                        name?: string | undefined;
+                        slug?: string | undefined;
+                    };
+                    orgId?: string | undefined;
                 }>;
-                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;
+                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;
                         };
-                    }>, 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;
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions>[];
+            }>): Promise<{
+                id: string;
+                name: string;
+                slug: string;
+            } | null>;
+            path: "/organization/update";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    data: ZodObject<{
+                        name: ZodOptional<ZodOptional<z.ZodString>>;
+                        slug: ZodOptional<ZodOptional<z.ZodString>>;
+                    }, "strip", z.ZodTypeAny, {
+                        name?: string | undefined;
+                        slug?: string | undefined;
                     }, {
-                        code: string;
+                        name?: string | undefined;
+                        slug?: 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;
+                    orgId: ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    data: {
+                        name?: string | undefined;
+                        slug?: string | undefined;
+                    };
+                    orgId?: string | undefined;
+                }, {
+                    data: {
+                        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;
                         };
-                    }>, better_call.EndpointOptions>[];
-                }>): Promise<{
-                    status: boolean;
+                        user: User;
+                    }>;
+                }>, better_call.EndpointOptions>[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        deleteOrganization: {
+            (ctx_0: better_call.Context<"/organization/delete", {
+                method: "POST";
+                body: ZodObject<{
+                    orgId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    orgId: string;
+                }, {
+                    orgId: string;
                 }>;
-                path: "/two-factor/verify-otp";
-                options: {
-                    method: "POST";
-                    body: zod.ZodObject<{
-                        code: zod.ZodString;
-                    }, "strip", zod.ZodTypeAny, {
-                        code: string;
-                    }, {
-                        code: string;
+                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;
                     }>;
-                    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";
-                        }>;
+                }>, better_call.EndpointOptions>[];
+            }>): Promise<string | null>;
+            path: "/organization/delete";
+            options: {
+                method: "POST";
+                body: ZodObject<{
+                    orgId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    orgId: string;
+                }, {
+                    orgId: string;
+                }>;
+                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/activate", {
+                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;
-                            user: UserWithTwoFactor;
+                            ipAddress?: string | undefined;
+                            userAgent?: string | undefined;
                         };
-                    }>, better_call.EndpointOptions>[];
-                };
-                method: better_call.Method | better_call.Method[];
-                headers: Headers;
+                        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: "member" | "admin" | "owner";
+                }[];
+                invitations: {
+                    id: string;
+                    expiresAt: Date;
+                    status: "pending" | "accepted" | "rejected" | "canceled";
+                    email: string;
+                    organizationId: string;
+                    role: "member" | "admin" | "owner";
+                    inviterId: string;
+                }[];
+                id: string;
+                name: string;
+                slug: string;
+            } | null>;
+            path: "/organization/activate";
+            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>)[];
             };
-            generateTOTP: {
-                (ctx_0?: better_call.Context<"/totp/generate", {
-                    method: "POST";
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        getFullOrganization: {
+            (ctx_0: better_call.Context<"/organization/get-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: {
@@ -596,12 +779,16 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                }> | undefined): Promise<{
-                    code: string;
-                }>;
-                path: "/totp/generate";
-                options: {
-                    method: "POST";
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
                     use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                         session: {
                             session: {
@@ -622,13 +809,54 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, 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";
+                } & {
+                    method: "*";
+                }>)[];
+            }>): Promise<{
+                members: {
+                    id: string;
+                    userId: string;
+                    name: string;
+                    email: string;
+                    organizationId: string;
+                    role: "member" | "admin" | "owner";
+                }[];
+                invitations: {
+                    id: string;
+                    expiresAt: Date;
+                    status: "pending" | "accepted" | "rejected" | "canceled";
+                    email: string;
+                    organizationId: string;
+                    role: "member" | "admin" | "owner";
+                    inviterId: string;
+                }[];
+                id: string;
+                name: string;
+                slug: string;
+            } | null>;
+            path: "/organization/get-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: {
@@ -649,12 +877,16 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                }> | undefined): Promise<{
-                    totpURI: string;
-                }>;
-                path: "/two-factor/get-totp-uri";
-                options: {
-                    method: "GET";
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
                     use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                         session: {
                             session: {
@@ -675,297 +907,101 @@ declare const twoFactorClient: (options?: {
                             };
                         };
                     }>, better_call.EndpointOptions>[];
-                };
-                method: better_call.Method | better_call.Method[];
-                headers: Headers;
+                } & {
+                    method: "*";
+                }>)[];
             };
-            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;
+            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, {
-                        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;
+                            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<{
-                    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;
-                    }>;
+                } & {
+                    method: "*";
+                }, {
+                    session: {
+                        session: Session & {
+                            activeOrganizationId?: string;
+                        };
+                        user: User;
+                    };
+                }>, {
                     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;
+                            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;
-            };
-        };
-        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;
+                } & {
+                    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<{}>;
                     };
-                };
-            };
-        };
-    };
-    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;
-    name: string;
-    email: string;
-    userId: string;
-    organizationId: string;
-    role: "admin" | "member" | "owner";
-}, {
-    id: string;
-    name: string;
-    email: string;
-    userId: 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, {
-    status: "pending" | "accepted" | "rejected" | "canceled";
-    id: string;
-    email: string;
-    expiresAt: Date;
-    organizationId: string;
-    role: "admin" | "member" | "owner";
-    inviterId: string;
-}, {
-    id: string;
-    email: string;
-    expiresAt: Date;
-    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, {
+                    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: {
@@ -1018,46 +1054,26 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                     }>, better_call.EndpointOptions>[];
                 } & {
                     method: "*";
-                }>[];
-            }>): Promise<{
-                error: string;
-                success: boolean;
-            } | {
-                error: null;
-                success: boolean;
-            }>;
-            path: "/organization/has-permission";
-            options: {
+                }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        createInvitation: {
+            (ctx_0: better_call.Context<"/organization/invite-member", {
                 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, {
+                    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: {
@@ -1110,27 +1126,35 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                     }>, 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>;
+                    email: z.ZodString;
+                    role: z.ZodEnum<["admin", "member", "owner"]>;
+                    organizationId: ZodOptional<z.ZodString>;
+                    resend: ZodOptional<z.ZodBoolean>;
                 }, "strip", z.ZodTypeAny, {
-                    name: string;
-                    slug: string;
-                    userId?: string | undefined;
-                }, {
-                    name: string;
-                    slug: string;
-                    userId?: string | undefined;
+                    email: string;
+                    role: "member" | "admin" | "owner";
+                    organizationId?: string | undefined;
+                    resend?: boolean | undefined;
+                }, {
+                    email: string;
+                    role: "member" | "admin" | "owner";
+                    organizationId?: string | undefined;
+                    resend?: boolean | undefined;
                 }>;
+            }>): Promise<{
+                id: string;
+                expiresAt: Date;
+                status: "pending" | "accepted" | "rejected" | "canceled";
+                email: string;
+                organizationId: string;
+                role: "member" | "admin" | "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 & {
@@ -1196,34 +1220,35 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     method: "*";
                 }>)[];
-            }>): Promise<{
-                members: {
-                    id: string;
-                    name: string;
+                body: ZodObject<{
+                    email: z.ZodString;
+                    role: z.ZodEnum<["admin", "member", "owner"]>;
+                    organizationId: ZodOptional<z.ZodString>;
+                    resend: ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
                     email: string;
-                    userId: string;
-                    organizationId: string;
-                    role: "admin" | "member" | "owner";
-                }[];
-                id: string;
-                name: string;
-                slug: string;
-            } | null>;
-            path: "/organization/create";
-            options: {
+                    role: "member" | "admin" | "owner";
+                    organizationId?: string | undefined;
+                    resend?: boolean | undefined;
+                }, {
+                    email: string;
+                    role: "member" | "admin" | "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<{
-                    name: z.ZodString;
-                    slug: z.ZodString;
-                    userId: ZodOptional<z.ZodString>;
+                    invitationId: z.ZodString;
                 }, "strip", z.ZodTypeAny, {
-                    name: string;
-                    slug: string;
-                    userId?: string | undefined;
+                    invitationId: string;
                 }, {
-                    name: string;
-                    slug: string;
-                    userId?: string | undefined;
+                    invitationId: string;
                 }>;
                 use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                     orgOptions: OrganizationOptions;
@@ -1290,196 +1315,25 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     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;
-                    name: string;
-                    email: string;
-                    userId: string;
-                    organizationId: string;
-                    role: "admin" | "member" | "owner";
-                }[];
-                invitations: {
-                    status: "pending" | "accepted" | "rejected" | "canceled";
-                    id: string;
-                    email: string;
-                    expiresAt: Date;
-                    organizationId: string;
-                    role: "admin" | "member" | "owner";
-                    inviterId: string;
-                }[];
                 id: string;
-                name: string;
-                slug: string;
+                expiresAt: Date;
+                status: "pending" | "accepted" | "rejected" | "canceled";
+                email: string;
+                organizationId: string;
+                role: "member" | "admin" | "owner";
+                inviterId: string;
             } | null>;
-            path: "/organization/set-active";
+            path: "/organization/cancel-invitation";
             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>;
+                    invitationId: z.ZodString;
                 }, "strip", z.ZodTypeAny, {
-                    orgId?: string | undefined;
+                    invitationId: string;
                 }, {
-                    orgId?: string | undefined;
+                    invitationId: string;
                 }>;
-                requireHeaders: true;
                 use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                     orgOptions: OrganizationOptions;
                     roles: typeof defaultRoles & {
@@ -1545,39 +1399,20 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     method: "*";
                 }>)[];
-            }>): Promise<{
-                members: {
-                    id: string;
-                    name: string;
-                    email: string;
-                    userId: string;
-                    organizationId: string;
-                    role: "admin" | "member" | "owner";
-                }[];
-                invitations: {
-                    status: "pending" | "accepted" | "rejected" | "canceled";
-                    id: string;
-                    email: string;
-                    expiresAt: Date;
-                    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>;
+            };
+            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, {
-                    orgId?: string | undefined;
+                    invitationId: string;
                 }, {
-                    orgId?: string | undefined;
+                    invitationId: string;
                 }>;
-                requireHeaders: true;
                 use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                     orgOptions: OrganizationOptions;
                     roles: typeof defaultRoles & {
@@ -1643,13 +1478,35 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     method: "*";
                 }>)[];
-            };
-            method: better_call.Method | better_call.Method[];
-            headers: Headers;
-        };
-        listOrganization: {
-            (ctx_0?: better_call.Context<"/organization/list", {
-                method: "GET";
+            }>): Promise<{
+                invitation: {
+                    id: string;
+                    expiresAt: Date;
+                    status: "pending" | "accepted" | "rejected" | "canceled";
+                    email: string;
+                    organizationId: string;
+                    role: "member" | "admin" | "owner";
+                    inviterId: string;
+                };
+                member: {
+                    id: string;
+                    userId: string;
+                    name: string;
+                    email: string;
+                    organizationId: string;
+                    role: "member" | "admin" | "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 & {
@@ -1715,14 +1572,81 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     method: "*";
                 }>)[];
-            }> | undefined): Promise<{
+            };
+            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;
-                name: string;
-                slug: string;
-            }[]>;
-            path: "/organization/list";
+                expiresAt: Date;
+                status: "pending" | "accepted" | "rejected" | "canceled";
+                email: string;
+                organizationId: string;
+                role: "member" | "admin" | "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 & {
@@ -1788,13 +1712,28 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     method: "*";
                 }>)[];
-            };
-            method: better_call.Method | better_call.Method[];
-            headers: Headers;
-        };
-        createInvitation: {
-            (ctx_0: better_call.Context<"/organization/invite-member", {
+            }>): Promise<{
+                invitation: {
+                    id: string;
+                    expiresAt: Date;
+                    status: "pending" | "accepted" | "rejected" | "canceled";
+                    email: string;
+                    organizationId: string;
+                    role: "member" | "admin" | "owner";
+                    inviterId: string;
+                } | null;
+                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 & {
@@ -1860,34 +1799,23 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     method: "*";
                 }>)[];
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        removeMember: {
+            (ctx_0: better_call.Context<"/organization/remove-member", {
+                method: "POST";
                 body: ZodObject<{
-                    email: z.ZodString;
-                    role: z.ZodEnum<["admin", "member", "owner"]>;
+                    memberIdOrEmail: z.ZodString;
                     organizationId: ZodOptional<z.ZodString>;
-                    resend: ZodOptional<z.ZodBoolean>;
                 }, "strip", z.ZodTypeAny, {
-                    email: string;
-                    role: "admin" | "member" | "owner";
+                    memberIdOrEmail: string;
                     organizationId?: string | undefined;
-                    resend?: boolean | undefined;
                 }, {
-                    email: string;
-                    role: "admin" | "member" | "owner";
+                    memberIdOrEmail: string;
                     organizationId?: string | undefined;
-                    resend?: boolean | undefined;
                 }>;
-            }>): Promise<{
-                status: "pending" | "accepted" | "rejected" | "canceled";
-                id: string;
-                email: string;
-                expiresAt: Date;
-                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 & {
@@ -1953,35 +1881,28 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     method: "*";
                 }>)[];
+            }>): Promise<{
+                member: {
+                    id: string;
+                    userId: string;
+                    name: string;
+                    email: string;
+                    organizationId: string;
+                    role: "member" | "admin" | "owner";
+                };
+            } | null>;
+            path: "/organization/remove-member";
+            options: {
+                method: "POST";
                 body: ZodObject<{
-                    email: z.ZodString;
-                    role: z.ZodEnum<["admin", "member", "owner"]>;
+                    memberIdOrEmail: z.ZodString;
                     organizationId: ZodOptional<z.ZodString>;
-                    resend: ZodOptional<z.ZodBoolean>;
                 }, "strip", z.ZodTypeAny, {
-                    email: string;
-                    role: "admin" | "member" | "owner";
+                    memberIdOrEmail: string;
                     organizationId?: string | undefined;
-                    resend?: boolean | undefined;
                 }, {
-                    email: string;
-                    role: "admin" | "member" | "owner";
+                    memberIdOrEmail: string;
                     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;
@@ -2048,24 +1969,25 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     method: "*";
                 }>)[];
-            }>): Promise<{
-                status: "pending" | "accepted" | "rejected" | "canceled";
-                id: string;
-                email: string;
-                expiresAt: Date;
-                organizationId: string;
-                role: "admin" | "member" | "owner";
-                inviterId: string;
-            } | null>;
-            path: "/organization/cancel-invitation";
-            options: {
+            };
+            method: better_call.Method | better_call.Method[];
+            headers: Headers;
+        };
+        updateMemberRole: {
+            (ctx_0: better_call.Context<"/organization/update-member-role", {
                 method: "POST";
                 body: ZodObject<{
-                    invitationId: z.ZodString;
+                    role: z.ZodEnum<["admin", "member", "owner"]>;
+                    memberId: z.ZodString;
+                    organizationId: ZodOptional<z.ZodString>;
                 }, "strip", z.ZodTypeAny, {
-                    invitationId: string;
+                    role: "member" | "admin" | "owner";
+                    memberId: string;
+                    organizationId?: string | undefined;
                 }, {
-                    invitationId: string;
+                    role: "member" | "admin" | "owner";
+                    memberId: string;
+                    organizationId?: string | undefined;
                 }>;
                 use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                     orgOptions: OrganizationOptions;
@@ -2132,113 +2054,29 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
                 } & {
                     method: "*";
                 }>)[];
-            };
-            method: better_call.Method | better_call.Method[];
-            headers: Headers;
-        };
-        acceptInvitation: {
-            (ctx_0: better_call.Context<"/organization/accept-invitation", {
+            }>): Promise<{
+                id: string;
+                userId: string;
+                name: string;
+                email: string;
+                organizationId: string;
+                role: "member" | "admin" | "owner";
+            } | null>;
+            path: "/organization/update-member-role";
+            options: {
                 method: "POST";
                 body: ZodObject<{
-                    invitationId: z.ZodString;
+                    role: z.ZodEnum<["admin", "member", "owner"]>;
+                    memberId: z.ZodString;
+                    organizationId: ZodOptional<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: {
-                    status: "pending" | "accepted" | "rejected" | "canceled";
-                    id: string;
-                    email: string;
-                    expiresAt: Date;
-                    organizationId: string;
-                    role: "admin" | "member" | "owner";
-                    inviterId: string;
-                };
-                member: {
-                    id: string;
-                    name: string;
-                    email: string;
-                    userId: 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;
+                    role: "member" | "admin" | "owner";
+                    memberId: string;
+                    organizationId?: string | undefined;
                 }, {
-                    invitationId: string;
+                    role: "member" | "admin" | "owner";
+                    memberId: string;
+                    organizationId?: string | undefined;
                 }>;
                 use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
                     orgOptions: OrganizationOptions;
@@ -2309,636 +2147,976 @@ declare const organization: <O extends OrganizationOptions>(options?: O) => {
             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;
-                status: "pending" | "accepted" | "rejected" | "canceled";
-                id: string;
-                email: string;
-                expiresAt: Date;
-                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;
-                }>;
+    };
+    schema: {
+        session: {
+            fields: {
+                activeOrganizationId: {
+                    type: "string";
+                    required: false;
+                };
             };
-            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: {
-                    status: "pending" | "accepted" | "rejected" | "canceled";
-                    id: string;
-                    email: string;
-                    expiresAt: Date;
-                    organizationId: string;
-                    role: "admin" | "member" | "owner";
-                    inviterId: string;
+        organization: {
+            fields: {
+                name: {
+                    type: "string";
                 };
-                member: null;
-            } | null>;
-            path: "/organization/reject-invitation";
-            options: {
-                method: "POST";
-                body: ZodObject<{
-                    invitationId: z.ZodString;
+                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 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;
+}) => {
+    id: "two-factor";
+    $InferServerPlugin: ReturnType<typeof twoFactor>;
+    atomListeners: {
+        matcher: (path: string) => path is "/two-factor/send-otp" | "/two-factor/enable" | "/two-factor/disable";
+        signal: string;
+    }[];
+    pathMethods: {
+        "enable/totp": "POST";
+        "/two-factor/disable": "POST";
+        "/two-factor/enable": "POST";
+        "/two-factor/send-otp": "POST";
+    };
+    fetchPlugins: {
+        id: string;
+        name: string;
+        hooks: {
+            onSuccess(context: _better_fetch_fetch.SuccessContext): Promise<void>;
+        };
+    }[];
+};
+
+declare const twoFactor: <O extends TwoFactorOptions>(options: O) => {
+    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: z.ZodObject<{
+                    code: z.ZodString;
                 }, "strip", z.ZodTypeAny, {
-                    invitationId: string;
+                    code: string;
                 }, {
-                    invitationId: string;
+                    code: string;
                 }>;
-                use: (better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
-                    orgOptions: OrganizationOptions;
-                    roles: typeof defaultRoles & {
-                        [key: string]: Role<{}>;
+                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;
                     };
-                    getSession: (context: better_call.Context<any, any>) => Promise<{
-                        session: Session & {
-                            activeOrganizationId?: string;
+                }>, better_call.EndpointOptions>[];
+            }>): Promise<{
+                status: boolean;
+            }>;
+            path: "/two-factor/verify-backup-code";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                }, "strip", z.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;
                         };
-                        user: User;
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
                     }>;
-                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
-                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    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: {
-                            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;
-                            };
+                            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";
+                body: z.ZodOptional<z.ZodObject<{
+                    returnOTP: z.ZodDefault<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    returnOTP: boolean;
+                }, {
+                    returnOTP?: boolean | 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>[];
+            }> | undefined): Promise<{
+                OTP: string;
+                status: boolean;
+            } | {
+                status: boolean;
+                OTP: undefined;
+            }>;
+            path: "/two-factor/send-otp";
+            options: {
+                method: "POST";
+                body: z.ZodOptional<z.ZodObject<{
+                    returnOTP: z.ZodDefault<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    returnOTP: boolean;
+                }, {
+                    returnOTP?: boolean | 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;
                         };
-                    }>, better_call.EndpointOptions>[];
-                } & {
-                    method: "*";
-                }, {
+                        _flag: "json";
+                    }>;
                     session: {
-                        session: Session & {
-                            activeOrganizationId?: string;
-                        };
-                        user: User;
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
                     };
-                }>, {
-                    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.EndpointOptions>[];
             };
             method: better_call.Method | better_call.Method[];
             headers: Headers;
         };
-        removeMember: {
-            (ctx_0: better_call.Context<"/organization/remove-member", {
+        verifyOTP: {
+            (ctx_0: better_call.Context<"/two-factor/verify-otp", {
                 method: "POST";
-                body: ZodObject<{
-                    memberId: z.ZodString;
+                body: z.ZodObject<{
+                    code: z.ZodString;
                 }, "strip", z.ZodTypeAny, {
-                    memberId: string;
+                    code: string;
                 }, {
-                    memberId: string;
+                    code: 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;
+                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;
                         };
-                        user: User;
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
                     }>;
-                }>, 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;
-                            };
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
                         };
-                    }>, better_call.EndpointOptions>[];
-                } & {
-                    method: "*";
-                }, {
-                    session: {
-                        session: Session & {
-                            activeOrganizationId?: string;
+                        body: {
+                            status: boolean;
                         };
-                        user: User;
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
                     };
-                }>, {
-                    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";
+                }>, better_call.EndpointOptions>[];
+            }>): Promise<{
+                status: boolean;
+            }>;
+            path: "/two-factor/verify-otp";
             options: {
                 method: "POST";
-                body: ZodObject<{
-                    memberId: z.ZodString;
+                body: z.ZodObject<{
+                    code: z.ZodString;
                 }, "strip", z.ZodTypeAny, {
-                    memberId: string;
+                    code: string;
                 }, {
-                    memberId: string;
+                    code: 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;
+                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;
                         };
-                        user: User;
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
                     }>;
-                }>, better_call.EndpointOptions> | better_call.Endpoint<better_call.Handler<string, {
-                    use: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                    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: {
-                            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;
-                            };
+                            id: string;
+                            userId: string;
+                            expiresAt: Date;
+                            ipAddress?: string | undefined;
+                            userAgent?: string | undefined;
                         };
-                    }>, better_call.EndpointOptions>[];
-                } & {
-                    method: "*";
-                }, {
+                        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: Session & {
-                            activeOrganizationId?: string;
+                        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;
                         };
-                        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: "*";
-                }>)[];
+                }>, better_call.EndpointOptions>[];
             };
             method: better_call.Method | better_call.Method[];
             headers: Headers;
         };
-        updateMember: {
-            (ctx_0: better_call.Context<"/organization/update-member", {
+        verifyTOTP: {
+            (ctx_0: better_call.Context<"/two-factor/verify-totp", {
                 method: "POST";
-                body: ZodObject<{
-                    memberId: z.ZodString;
-                    role: z.ZodString;
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                    callbackURL: z.ZodOptional<z.ZodString>;
                 }, "strip", z.ZodTypeAny, {
-                    role: string;
-                    memberId: string;
+                    code: string;
+                    callbackURL?: string | undefined;
                 }, {
-                    role: string;
-                    memberId: string;
+                    code: string;
+                    callbackURL?: 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;
+                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;
                         };
-                        user: User;
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
                     }>;
-                }>, 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;
-                            };
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
                         };
-                    }>, better_call.EndpointOptions>[];
-                } & {
-                    method: "*";
-                }, {
-                    session: {
-                        session: Session & {
-                            activeOrganizationId?: string;
+                        body: {
+                            status: boolean;
                         };
-                        user: User;
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
                     };
-                }>, {
-                    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.EndpointOptions>[];
             }>): Promise<{
-                id: string;
-                name: string;
-                email: string;
-                userId: string;
-                organizationId: string;
-                role: "admin" | "member" | "owner";
-            } | null>;
-            path: "/organization/update-member";
+                status: boolean;
+            }>;
+            path: "/two-factor/verify-totp";
             options: {
                 method: "POST";
-                body: ZodObject<{
-                    memberId: z.ZodString;
-                    role: z.ZodString;
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                    callbackURL: z.ZodOptional<z.ZodString>;
                 }, "strip", z.ZodTypeAny, {
-                    role: string;
-                    memberId: string;
+                    code: string;
+                    callbackURL?: string | undefined;
                 }, {
-                    role: string;
-                    memberId: string;
+                    code: string;
+                    callbackURL?: 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;
+                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;
                         };
-                        user: User;
+                        body: {
+                            status: boolean;
+                        };
+                        _flag: "json";
                     }>;
-                }>, 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;
-                            };
+                    invalid: () => Promise<{
+                        response: {
+                            body: any;
+                            status: number;
+                            statusText: string;
+                            headers: Record<string, string> | undefined;
                         };
-                    }>, better_call.EndpointOptions>[];
-                } & {
-                    method: "*";
-                }, {
-                    session: {
-                        session: Session & {
-                            activeOrganizationId?: string;
+                        body: {
+                            status: boolean;
                         };
-                        user: User;
+                        _flag: "json";
+                    }>;
+                    session: {
+                        id: string;
+                        userId: string;
+                        expiresAt: Date;
+                        user: UserWithTwoFactor;
                     };
-                }>, {
-                    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.EndpointOptions>[];
             };
             method: better_call.Method | better_call.Method[];
             headers: Headers;
         };
     };
+    options: O;
+    hooks: {
+        after: {
+            matcher(context: HookEndpointContext): boolean;
+            handler: better_call.Endpoint<better_call.Handler<string, better_call.EndpointOptions, {
+                response: Response;
+            } | undefined>, better_call.EndpointOptions>;
+        }[];
+    };
     schema: {
-        session: {
+        user: {
             fields: {
-                activeOrganizationId: {
-                    type: "string";
+                twoFactorEnabled: {
+                    type: "boolean";
                     required: false;
+                    defaultValue: 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: {
+                twoFactorSecret: {
                     type: "string";
                     required: false;
                 };
-                status: {
-                    type: "string";
-                    required: true;
-                    defaultValue: string;
-                };
-                expiresAt: {
-                    type: "date";
-                    required: true;
-                };
-                inviterId: {
+                twoFactorBackupCodes: {
                     type: "string";
-                    references: {
-                        model: string;
-                        field: string;
-                    };
+                    required: false;
+                    returned: false;
                 };
             };
         };
     };
 };
 
+declare const getPasskeyActions: ($fetch: BetterFetch) => {
+    signIn: {
+        passkey: (opts?: {
+            autoFill?: boolean;
+            email?: string;
+            callbackURL?: string;
+        }) => Promise<{
+            data: null;
+            error: {
+                message?: string | undefined;
+                status: number;
+                statusText: string;
+            };
+        } | undefined>;
+    };
+    passkey: {
+        register: () => Promise<{
+            data: null;
+            error: {
+                message?: string | undefined;
+                status: number;
+                statusText: string;
+            };
+        } | undefined>;
+    };
+};
+declare const passkeyClient: () => {
+    id: "passkey";
+    $InferServerPlugin: ReturnType<typeof passkey>;
+    getActions: ($fetch: BetterFetch) => {
+        signIn: {
+            passkey: (opts?: {
+                autoFill?: boolean;
+                email?: string;
+                callbackURL?: string;
+            }) => Promise<{
+                data: null;
+                error: {
+                    message?: string | undefined;
+                    status: number;
+                    statusText: string;
+                };
+            } | undefined>;
+        };
+        passkey: {
+            register: () => Promise<{
+                data: null;
+                error: {
+                    message?: string | undefined;
+                    status: number;
+                    statusText: string;
+                };
+            } | undefined>;
+        };
+    };
+    pathMethods: {
+        "/passkey/register": "POST";
+        "/passkey/authenticate": "POST";
+    };
+};
+
 interface PasskeyOptions {
     /**
      * A unique identifier for your website. 'localhost' is okay for
@@ -3051,11 +3229,11 @@ declare const passkey: (options: PasskeyOptions) => {
                     email: z.ZodOptional<z.ZodString>;
                     callbackURL: z.ZodOptional<z.ZodString>;
                 }, "strip", z.ZodTypeAny, {
-                    callbackURL?: string | undefined;
                     email?: string | undefined;
-                }, {
                     callbackURL?: string | undefined;
+                }, {
                     email?: string | undefined;
+                    callbackURL?: string | undefined;
                 }>>;
             }> | undefined): Promise<_simplewebauthn_types.PublicKeyCredentialRequestOptionsJSON>;
             path: "/passkey/generate-authenticate-options";
@@ -3065,11 +3243,11 @@ declare const passkey: (options: PasskeyOptions) => {
                     email: z.ZodOptional<z.ZodString>;
                     callbackURL: z.ZodOptional<z.ZodString>;
                 }, "strip", z.ZodTypeAny, {
-                    callbackURL?: string | undefined;
                     email?: string | undefined;
-                }, {
                     callbackURL?: string | undefined;
+                }, {
                     email?: string | undefined;
+                    callbackURL?: string | undefined;
                 }>>;
             };
             method: better_call.Method | better_call.Method[];
@@ -3213,291 +3391,156 @@ declare const passkey: (options: PasskeyOptions) => {
     };
 };
 
-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;
-                    };
+declare const username: () => {
+    id: "username";
+    endpoints: {
+        signInUsername: {
+            (ctx_0: better_call.Context<"/sign-in/username", {
+                method: "POST";
+                body: z.ZodObject<{
+                    username: z.ZodString;
+                    password: z.ZodString;
+                    dontRememberMe: z.ZodOptional<z.ZodBoolean>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    password: string;
+                    username: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }, {
+                    password: string;
+                    username: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }>;
+            }>): Promise<{
+                user: {
+                    id: string;
+                    name: string;
+                    email: string;
+                    emailVerified: boolean;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    image?: string | undefined;
                 };
-                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, {
-                        callbackURL?: string | undefined;
-                        email?: string | undefined;
-                    }, {
-                        callbackURL?: string | undefined;
-                        email?: 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, {
-                        callbackURL?: string | undefined;
-                        email?: string | undefined;
-                    }, {
-                        callbackURL?: string | undefined;
-                        email?: string | undefined;
-                    }>>;
+                session: {
+                    id: string;
+                    userId: string;
+                    expiresAt: Date;
+                    ipAddress?: string | undefined;
+                    userAgent?: string | undefined;
                 };
-                method: better_call.Method | better_call.Method[];
-                headers: Headers;
+                redirect: boolean;
+                url: string | undefined;
+            }>;
+            path: "/sign-in/username";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    username: z.ZodString;
+                    password: z.ZodString;
+                    dontRememberMe: z.ZodOptional<z.ZodBoolean>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    password: string;
+                    username: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }, {
+                    password: string;
+                    username: string;
+                    callbackURL?: string | undefined;
+                    dontRememberMe?: boolean | undefined;
+                }>;
             };
-            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;
+        };
+        signUpUsername: {
+            (ctx_0: better_call.Context<"/sign-up/username", {
+                method: "POST";
+                body: z.ZodObject<{
+                    username: z.ZodString;
+                    name: z.ZodString;
+                    email: z.ZodString;
+                    password: z.ZodString;
+                    image: z.ZodOptional<z.ZodString>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    username: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    username: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }>;
+            }>): Promise<{
+                user: {
+                    id: string;
+                    name: string;
+                    email: string;
+                    emailVerified: boolean;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    image?: string | undefined;
                 };
-                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;
-                    }>;
+                session: {
+                    id: string;
+                    userId: string;
+                    expiresAt: Date;
+                    ipAddress?: string | undefined;
+                    userAgent?: string | undefined;
                 };
-                method: better_call.Method | better_call.Method[];
-                headers: Headers;
+            } | null>;
+            path: "/sign-up/username";
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    username: z.ZodString;
+                    name: z.ZodString;
+                    email: z.ZodString;
+                    password: z.ZodString;
+                    image: z.ZodOptional<z.ZodString>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    username: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }, {
+                    password: string;
+                    name: string;
+                    email: string;
+                    username: string;
+                    image?: string | undefined;
+                    callbackURL?: string | undefined;
+                }>;
             };
+            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;
-                    };
+    };
+    schema: {
+        user: {
+            fields: {
+                username: {
+                    type: "string";
+                    required: false;
+                    unique: true;
+                    returned: true;
                 };
             };
         };
     };
-    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 };
+export { type Invitation as I, type Member as M, type OrganizationOptions as O, type PasskeyOptions as P, type WebAuthnCookieType as W, twoFactorClient as a, type Passkey as b, passkeyClient as c, getPasskeyActions as g, organization as o, passkey as p, twoFactor as t, username as u };