import * as z from 'zod/v4';
import { U as User, S as Session, p as AuthContext, a4 as FieldAttribute, af as InferAdditionalFieldsFromPluginOptions, G as GenericEndpointContext } from '../../shared/better-auth.UgZtsmr9.js';
import { AccessControl, Role, Statements } from '../access/index.js';
import * as better_call from 'better-call';
import { Prettify } from 'better-call';
import { defaultRoles } from './access/index.js';
export { adminAc, defaultAc, defaultStatements, memberAc, ownerAc } from './access/index.js';
import 'kysely';
import '../../shared/better-auth.ZSfSbnQT.js';
import '../../shared/better-auth.BVGuK4ar.js';
import 'jose';
import 'zod/v4/core';
import 'zod';
import 'better-sqlite3';
import 'bun:sqlite';

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);
    /**
     * The maximum number of organizations a user can create.
     *
     * You can also pass a function that returns a boolean
     */
    organizationLimit?: number | ((user: User) => Promise<boolean> | boolean);
    /**
     * The role that is assigned to the creator of the
     * organization.
     *
     * @default "owner"
     */
    creatorRole?: string;
    /**
     * The maximum number of members allowed in an organization.
     *
     * @default 100
     */
    membershipLimit?: number;
    /**
     * Configure the roles and permissions for the
     * organization plugin.
     */
    ac?: AccessControl;
    /**
     * Custom permissions for roles.
     */
    roles?: {
        [key in string]?: Role<any>;
    };
    /**
     * Support for team.
     */
    teams?: {
        /**
         * Enable team features.
         */
        enabled: boolean;
        /**
         * Default team configuration
         */
        defaultTeam?: {
            /**
             * Enable creating a default team when an organization is created
             *
             * @default true
             */
            enabled: boolean;
            /**
             * Pass a custom default team creator function
             */
            customCreateDefaultTeam?: (organization: Organization & Record<string, any>, request?: Request) => Promise<Team & Record<string, any>>;
        };
        /**
         * Maximum number of teams an organization can have.
         *
         * You can pass a number or a function that returns a number
         *
         * @default "unlimited"
         *
         * @param organization
         * @param request
         * @returns
         */
        maximumTeams?: ((data: {
            organizationId: string;
            session: {
                user: User;
                session: Session;
            } | null;
        }, request?: Request) => number | Promise<number>) | number;
        /**
         * The maximum number of members per team.
         *
         * if `undefined`, there is no limit.
         *
         * @default undefined
         */
        maximumMembersPerTeam?: number | ((data: {
            teamId: string;
            session: {
                user: User;
                session: Session;
            };
            organizationId: string;
        }) => Promise<number> | number) | undefined;
        /**
         * By default, if an organization does only have one team, they'll not be able to remove it.
         *
         * You can disable this behavior by setting this to `false.
         *
         * @default false
         */
        allowRemovingAllTeams?: boolean;
    };
    /**
     * The expiration time for the invitation link.
     *
     * @default 48 hours
     */
    invitationExpiresIn?: number;
    /**
     * The maximum invitation a user can send.
     *
     * @default 100
     */
    invitationLimit?: number | ((data: {
        user: User;
        organization: Organization;
        member: Member;
    }, ctx: AuthContext) => Promise<number> | number);
    /**
     * Cancel pending invitations on re-invite.
     *
     * @default false
     */
    cancelPendingInvitationsOnReInvite?: boolean;
    /**
     * Send an email with the
     * invitation link to the user.
     *
     * Note: Better Auth doesn't
     * generate invitation URLs.
     * You'll need to construct the
     * URL using the invitation ID
     * and pass it to the
     * acceptInvitation endpoint for
     * the user to accept the
     * invitation.
     *
     * @example
     * ```ts
     * sendInvitationEmail: async (data) => {
     * 	const url = `https://yourapp.com/organization/
     * accept-invitation?id=${data.id}`;
     * 	await sendEmail(data.email, "Invitation to join
     * organization", `Click the link to join the
     * organization: ${url}`);
     * }
     * ```
     */
    sendInvitationEmail?: (data: {
        /**
         * the invitation id
         */
        id: string;
        /**
         * the role of the user
         */
        role: string;
        /**
         * the email of the user
         */
        email: string;
        /**
         * the organization the user is invited to join
         */
        organization: Organization;
        /**
         * the invitation object
         */
        invitation: Invitation;
        /**
         * the member who is inviting the user
         */
        inviter: Member & {
            user: User;
        };
    }, 
    /**
     * The request object
     */
    request?: Request) => Promise<void>;
    /**
     * The schema for the organization plugin.
     */
    schema?: {
        session?: {
            fields?: {
                activeOrganizationId?: string;
                activeTeamId?: string;
            };
        };
        organization?: {
            modelName?: string;
            fields?: {
                [key in keyof Omit<Organization, "id">]?: string;
            };
            additionalFields?: {
                [key in string]: FieldAttribute;
            };
        };
        member?: {
            modelName?: string;
            fields?: {
                [key in keyof Omit<Member, "id">]?: string;
            };
            additionalFields?: {
                [key in string]: FieldAttribute;
            };
        };
        invitation?: {
            modelName?: string;
            fields?: {
                [key in keyof Omit<Invitation, "id">]?: string;
            };
            additionalFields?: {
                [key in string]: FieldAttribute;
            };
        };
        team?: {
            modelName?: string;
            fields?: {
                [key in keyof Omit<Team, "id">]?: string;
            };
            additionalFields?: {
                [key in string]: FieldAttribute;
            };
        };
        teamMember?: {
            modelName?: string;
            fields?: {
                [key in keyof Omit<TeamMember, "id">]?: string;
            };
        };
    };
    /**
     * Configure how organization deletion is handled
     */
    organizationDeletion?: {
        /**
         * disable deleting organization
         */
        disabled?: boolean;
        /**
         * A callback that runs before the organization is
         * deleted
         *
         * @param data - organization and user object
         * @param request - the request object
         * @returns
         */
        beforeDelete?: (data: {
            organization: Organization;
            user: User;
        }, request?: Request) => Promise<void>;
        /**
         * A callback that runs after the organization is
         * deleted
         *
         * @param data - organization and user object
         * @param request - the request object
         * @returns
         */
        afterDelete?: (data: {
            organization: Organization;
            user: User;
        }, request?: Request) => Promise<void>;
    };
    organizationCreation?: {
        disabled?: boolean;
        beforeCreate?: (data: {
            organization: Omit<Organization, "id"> & Record<string, any>;
            user: User;
        }, request?: Request) => Promise<void | {
            data: Record<string, any>;
        }>;
        afterCreate?: (data: {
            organization: Organization & Record<string, any>;
            member: Member & Record<string, any>;
            user: User;
        }, request?: Request) => Promise<void>;
    };
    /**
     * Automatically create an organization for the user on sign up.
     *
     * @default false
     */
    autoCreateOrganizationOnSignUp?: boolean;
}

declare const role: z.ZodString;
declare const invitationStatus: z.ZodDefault<z.ZodEnum<{
    accepted: "accepted";
    canceled: "canceled";
    rejected: "rejected";
    pending: "pending";
}>>;
declare const organizationSchema: z.ZodObject<{
    id: z.ZodDefault<z.ZodString>;
    name: z.ZodString;
    slug: z.ZodString;
    logo: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
    metadata: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>]>>;
    createdAt: z.ZodDate;
}, z.core.$strip>;
declare const memberSchema: z.ZodObject<{
    id: z.ZodDefault<z.ZodString>;
    organizationId: z.ZodString;
    userId: z.ZodCoercedString<unknown>;
    role: z.ZodString;
    createdAt: z.ZodDefault<z.ZodDate>;
}, z.core.$strip>;
declare const invitationSchema: z.ZodObject<{
    id: z.ZodDefault<z.ZodString>;
    organizationId: z.ZodString;
    email: z.ZodString;
    role: z.ZodString;
    status: z.ZodDefault<z.ZodEnum<{
        accepted: "accepted";
        canceled: "canceled";
        rejected: "rejected";
        pending: "pending";
    }>>;
    teamId: z.ZodOptional<z.ZodString>;
    inviterId: z.ZodString;
    expiresAt: z.ZodDate;
}, z.core.$strip>;
declare const teamSchema: z.ZodObject<{
    id: z.ZodDefault<z.ZodString>;
    name: z.ZodString;
    organizationId: z.ZodString;
    createdAt: z.ZodDate;
    updatedAt: z.ZodOptional<z.ZodDate>;
}, z.core.$strip>;
declare const teamMemberSchema: z.ZodObject<{
    id: z.ZodDefault<z.ZodString>;
    teamId: z.ZodString;
    userId: z.ZodString;
    createdAt: z.ZodDefault<z.ZodDate>;
}, z.core.$strip>;
type Organization = z.infer<typeof organizationSchema>;
type Member = z.infer<typeof memberSchema>;
type TeamMember = z.infer<typeof teamMemberSchema>;
type Team = z.infer<typeof teamSchema>;
type Invitation = z.infer<typeof invitationSchema>;
type InvitationInput = z.input<typeof invitationSchema>;
type MemberInput = z.input<typeof memberSchema>;
type TeamMemberInput = z.input<typeof teamMemberSchema>;
type OrganizationInput = z.input<typeof organizationSchema>;
type TeamInput = z.infer<typeof teamSchema>;
declare const defaultRolesSchema: z.ZodUnion<readonly [z.ZodEnum<{
    owner: "owner";
    member: "member";
    admin: "admin";
}>, z.ZodArray<z.ZodEnum<{
    owner: "owner";
    member: "member";
    admin: "admin";
}>>]>;
type CustomRolesSchema<O> = O extends {
    roles: {
        [key: string]: any;
    };
} ? z.ZodType<keyof O["roles"] | Array<keyof O["roles"]>> : typeof defaultRolesSchema;
type InferOrganizationZodRolesFromOption<O extends OrganizationOptions | undefined> = CustomRolesSchema<O>;
type InferOrganizationRolesFromOption<O extends OrganizationOptions | undefined> = O extends {
    roles: any;
} ? keyof O["roles"] : "admin" | "member" | "owner";
type InvitationStatus = "pending" | "accepted" | "rejected" | "canceled";
type InferMember<O extends OrganizationOptions> = O["teams"] extends {
    enabled: true;
} ? {
    id: string;
    organizationId: string;
    role: InferOrganizationRolesFromOption<O>;
    createdAt: Date;
    userId: string;
    teamId?: string;
    user: {
        email: string;
        name: string;
        image?: string;
    };
} : {
    id: string;
    organizationId: string;
    role: InferOrganizationRolesFromOption<O>;
    createdAt: Date;
    userId: string;
    user: {
        email: string;
        name: string;
        image?: string;
    };
};
type InferOrganization<O extends OrganizationOptions, isClientSide extends boolean = true> = Prettify<Organization & InferAdditionalFieldsFromPluginOptions<"organization", O, isClientSide>>;
type InferTeam<O extends OrganizationOptions> = Prettify<Team & InferAdditionalFieldsFromPluginOptions<"team", O>>;
type InferInvitation<O extends OrganizationOptions> = (O["teams"] extends {
    enabled: true;
} ? {
    id: string;
    organizationId: string;
    email: string;
    role: InferOrganizationRolesFromOption<O>;
    status: InvitationStatus;
    inviterId: string;
    expiresAt: Date;
    teamId?: string;
} : {
    id: string;
    organizationId: string;
    email: string;
    role: InferOrganizationRolesFromOption<O>;
    status: InvitationStatus;
    inviterId: string;
    expiresAt: Date;
}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>;

declare const getFullOrganization: <O extends OrganizationOptions>(options: O) => {
    <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
        body?: undefined;
    } & {
        method?: "GET" | undefined;
    } & {
        query?: {
            organizationId?: string | undefined;
            organizationSlug?: string | undefined;
            membersLimit?: string | number | undefined;
        } | undefined;
    } & {
        params?: Record<string, any>;
    } & {
        request?: Request;
    } & {
        headers: HeadersInit;
    } & {
        asResponse?: boolean;
        returnHeaders?: boolean;
        use?: better_call.Middleware[];
        path?: string;
    } & {
        asResponse?: AsResponse | undefined;
        returnHeaders?: ReturnHeaders | undefined;
    }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
        headers: Headers;
        response: (O["teams"] extends {
            enabled: true;
        } ? {
            members: InferMember<O>[];
            invitations: InferInvitation<O>[];
            teams: Team[];
        } & ({
            id: string;
            name: string;
            slug: string;
            createdAt: Date;
            logo?: string | null | undefined;
            metadata?: any;
        } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
            id: string;
            name: string;
            slug: string;
            createdAt: Date;
            logo?: string | null | undefined;
            metadata?: any;
        } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
            members: InferMember<O>[];
            invitations: InferInvitation<O>[];
        } & ({
            id: string;
            name: string;
            slug: string;
            createdAt: Date;
            logo?: string | null | undefined;
            metadata?: any;
        } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
            id: string;
            name: string;
            slug: string;
            createdAt: Date;
            logo?: string | null | undefined;
            metadata?: any;
        } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null;
    } : (O["teams"] extends {
        enabled: true;
    } ? {
        members: InferMember<O>[];
        invitations: InferInvitation<O>[];
        teams: Team[];
    } & ({
        id: string;
        name: string;
        slug: string;
        createdAt: Date;
        logo?: string | null | undefined;
        metadata?: any;
    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_2 ? { [K in keyof T_2]: ({
        id: string;
        name: string;
        slug: string;
        createdAt: Date;
        logo?: string | null | undefined;
        metadata?: any;
    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
        members: InferMember<O>[];
        invitations: InferInvitation<O>[];
    } & ({
        id: string;
        name: string;
        slug: string;
        createdAt: Date;
        logo?: string | null | undefined;
        metadata?: any;
    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_3 ? { [K in keyof T_3]: ({
        id: string;
        name: string;
        slug: string;
        createdAt: Date;
        logo?: string | null | undefined;
        metadata?: any;
    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null>;
    options: {
        method: "GET";
        query: z.ZodOptional<z.ZodObject<{
            organizationId: z.ZodOptional<z.ZodString>;
            organizationSlug: z.ZodOptional<z.ZodString>;
            membersLimit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
        }, z.core.$strip>>;
        requireHeaders: true;
        use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
            orgOptions: OrganizationOptions;
            roles: typeof defaultRoles & {
                [key: string]: Role<{}>;
            };
            getSession: (context: GenericEndpointContext) => Promise<{
                session: Session & {
                    activeTeamId?: string;
                    activeOrganizationId?: string;
                };
                user: User;
            }>;
        }>) | ((inputContext: better_call.MiddlewareInputContext<{
            use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                session: {
                    session: Record<string, any> & {
                        id: string;
                        userId: string;
                        expiresAt: Date;
                        createdAt: Date;
                        updatedAt: Date;
                        token: string;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    };
                    user: Record<string, any> & {
                        id: string;
                        email: string;
                        emailVerified: boolean;
                        name: string;
                        createdAt: Date;
                        updatedAt: Date;
                        image?: string | null | undefined;
                    };
                };
            }>)[];
        }>) => Promise<{
            session: {
                session: Session & {
                    activeTeamId?: string;
                    activeOrganizationId?: string;
                };
                user: User;
            };
        }>))[];
        metadata: {
            openapi: {
                description: string;
                responses: {
                    "200": {
                        description: string;
                        content: {
                            "application/json": {
                                schema: {
                                    type: "object";
                                    description: string;
                                    $ref: string;
                                };
                            };
                        };
                    };
                };
            };
        };
    } & {
        use: any[];
    };
    path: "/organization/get-full-organization";
};

declare function parseRoles(roles: string | string[]): string;
/**
 * Organization plugin for Better Auth. Organization allows you to create teams, members,
 * and manage access control for your users.
 *
 * @example
 * ```ts
 * const auth = betterAuth({
 * 	plugins: [
 * 		organization({
 * 			allowUserToCreateOrganization: true,
 * 		}),
 * 	],
 * });
 * ```
 */
declare const organization: <O extends OrganizationOptions>(options?: OrganizationOptions & O) => {
    id: "organization";
    endpoints: (O["teams"] extends {
        enabled: true;
    } ? {
        /**
         * ### Endpoint
         *
         * POST `/organization/create-team`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.createTeam`
         *
         * **client:**
         * `authClient.organization.createTeam`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-create-team)
         */
        createTeam: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(...inputCtx: better_call.HasRequiredKeys<better_call.InputContext<"/organization/create-team", {
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: {
                            name: string;
                            organizationId?: string | undefined;
                        } & InferAdditionalFieldsFromPluginOptions<"team", O, true>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                    description: string;
                                                };
                                                name: {
                                                    type: string;
                                                    description: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                    description: string;
                                                };
                                                createdAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                                updatedAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }>> extends true ? [better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: {
                            name: string;
                            organizationId?: string | undefined;
                        } & InferAdditionalFieldsFromPluginOptions<"team", O, true>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                    description: string;
                                                };
                                                name: {
                                                    type: string;
                                                    description: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                    description: string;
                                                };
                                                createdAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                                updatedAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, {
                name: string;
                organizationId?: string | undefined;
            } & InferAdditionalFieldsFromPluginOptions<"team", O, true>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }] : [((better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: {
                            name: string;
                            organizationId?: string | undefined;
                        } & InferAdditionalFieldsFromPluginOptions<"team", O, true>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                    description: string;
                                                };
                                                name: {
                                                    type: string;
                                                    description: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                    description: string;
                                                };
                                                createdAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                                updatedAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, {
                name: string;
                organizationId?: string | undefined;
            } & InferAdditionalFieldsFromPluginOptions<"team", O, true>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined)?]): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt?: Date | undefined;
                } & InferAdditionalFieldsFromPluginOptions<"team", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt?: Date | undefined;
                } & InferAdditionalFieldsFromPluginOptions<"team", O, true>)[K]; } : never;
            } : {
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt?: Date | undefined;
            } & InferAdditionalFieldsFromPluginOptions<"team", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt?: Date | undefined;
            } & InferAdditionalFieldsFromPluginOptions<"team", O, true>)[K]; } : never>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: {
                            name: string;
                            organizationId?: string | undefined;
                        } & InferAdditionalFieldsFromPluginOptions<"team", O, true>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                    description: string;
                                                };
                                                name: {
                                                    type: string;
                                                    description: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                    description: string;
                                                };
                                                createdAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                                updatedAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/create-team";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/list-teams`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listOrganizationTeams`
         *
         * **client:**
         * `authClient.organization.listTeams`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-list-teams)
         */
        listOrganizationTeams: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    organizationId?: string | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt?: Date | undefined;
                }[];
            } : {
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt?: Date | undefined;
            }[]>;
            options: {
                method: "GET";
                query: z.ZodOptional<z.ZodObject<{
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                requireHeaders: true;
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "array";
                                            items: {
                                                type: string;
                                                properties: {
                                                    id: {
                                                        type: string;
                                                        description: string;
                                                    };
                                                    name: {
                                                        type: string;
                                                        description: string;
                                                    };
                                                    organizationId: {
                                                        type: string;
                                                        description: string;
                                                    };
                                                    createdAt: {
                                                        type: string;
                                                        format: string;
                                                        description: string;
                                                    };
                                                    updatedAt: {
                                                        type: string;
                                                        format: string;
                                                        description: string;
                                                    };
                                                };
                                                required: string[];
                                            };
                                            description: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/list-teams";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/remove-team`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.removeTeam`
         *
         * **client:**
         * `authClient.organization.removeTeam`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-remove-team)
         */
        removeTeam: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    teamId: string;
                    organizationId?: string | undefined;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    message: string;
                } | null;
            } : {
                message: string;
            } | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    teamId: z.ZodString;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                message: {
                                                    type: string;
                                                    description: string;
                                                    enum: string[];
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/remove-team";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/update-team`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.updateTeam`
         *
         * **client:**
         * `authClient.organization.updateTeam`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-update-team)
         */
        updateTeam: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    teamId: string;
                    data: Partial<{
                        name: string;
                        organizationId: string;
                    } & InferAdditionalFieldsFromPluginOptions<"team", O, true>>;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: ({
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt?: Date | undefined;
                } & InferAdditionalFieldsFromPluginOptions<"team", O, true>) | null;
            } : ({
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt?: Date | undefined;
            } & InferAdditionalFieldsFromPluginOptions<"team", O, true>) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    teamId: z.ZodString;
                    data: z.ZodObject<{
                        id: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                        name: z.ZodOptional<z.ZodString>;
                        organizationId: z.ZodOptional<z.ZodString>;
                        createdAt: z.ZodOptional<z.ZodDate>;
                        updatedAt: z.ZodOptional<z.ZodOptional<z.ZodDate>>;
                    }, z.core.$strip>;
                }, z.core.$strip>;
                requireHeaders: true;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    $Infer: {
                        body: {
                            teamId: string;
                            data: Partial<{
                                name: string;
                                organizationId: string;
                            } & InferAdditionalFieldsFromPluginOptions<"team", O, true>>;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                    description: string;
                                                };
                                                name: {
                                                    type: string;
                                                    description: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                    description: string;
                                                };
                                                createdAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                                updatedAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/update-team";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/set-active-team`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.setActiveTeam`
         *
         * **client:**
         * `authClient.organization.setActiveTeam`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-set-active-team)
         */
        setActiveTeam: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    teamId?: string | null | undefined;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt?: Date | undefined;
                } | null;
            } : {
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt?: Date | undefined;
            } | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    teamId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/set-active-team";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/list-user-teams`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listUserTeams`
         *
         * **client:**
         * `authClient.organization.listUserTeams`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-set-active-team)
         */
        listUserTeams: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt?: Date | undefined;
                }[];
            } : {
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt?: Date | undefined;
            }[]>;
            options: {
                method: "GET";
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "array";
                                            items: {
                                                type: string;
                                                description: string;
                                                $ref: string;
                                            };
                                            description: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/list-user-teams";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/list-team-members`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listTeamMembers`
         *
         * **client:**
         * `authClient.organization.listTeamMembers`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-set-active-team)
         */
        listTeamMembers: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    teamId?: string | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    id: string;
                    teamId: string;
                    userId: string;
                    createdAt: Date;
                }[];
            } : {
                id: string;
                teamId: string;
                userId: string;
                createdAt: Date;
            }[]>;
            options: {
                method: "GET";
                query: z.ZodOptional<z.ZodObject<{
                    teamId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "array";
                                            items: {
                                                type: string;
                                                description: string;
                                                properties: {
                                                    id: {
                                                        type: string;
                                                        description: string;
                                                    };
                                                    userId: {
                                                        type: string;
                                                        description: string;
                                                    };
                                                    teamId: {
                                                        type: string;
                                                        description: string;
                                                    };
                                                    createdAt: {
                                                        type: string;
                                                        format: string;
                                                        description: string;
                                                    };
                                                };
                                                required: string[];
                                            };
                                            description: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/list-team-members";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/add-team-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.addTeamMember`
         *
         * **client:**
         * `authClient.organization.addTeamMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-add-team-member)
         */
        addTeamMember: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    teamId: string;
                    userId: unknown;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    id: string;
                    teamId: string;
                    userId: string;
                    createdAt: Date;
                };
            } : {
                id: string;
                teamId: string;
                userId: string;
                createdAt: Date;
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    teamId: z.ZodString;
                    userId: z.ZodCoercedString<unknown>;
                }, z.core.$strip>;
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            properties: {
                                                id: {
                                                    type: string;
                                                    description: string;
                                                };
                                                userId: {
                                                    type: string;
                                                    description: string;
                                                };
                                                teamId: {
                                                    type: string;
                                                    description: string;
                                                };
                                                createdAt: {
                                                    type: string;
                                                    format: string;
                                                    description: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/add-team-member";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/remove-team-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.removeTeamMember`
         *
         * **client:**
         * `authClient.organization.removeTeamMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-remove-team-member)
         */
        removeTeamMember: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    teamId: string;
                    userId: unknown;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    message: string;
                };
            } : {
                message: string;
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    teamId: z.ZodString;
                    userId: z.ZodCoercedString<unknown>;
                }, z.core.$strip>;
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                message: {
                                                    type: string;
                                                    description: string;
                                                    enum: string[];
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/remove-team-member";
        };
    } & {
        /**
         * ### Endpoint
         *
         * POST `/organization/create`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.createOrganization`
         *
         * **client:**
         * `authClient.organization.create`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-create)
         */
        createOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(...inputCtx: better_call.HasRequiredKeys<better_call.InputContext<"/organization/create", {
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    slug: z.ZodString;
                    userId: z.ZodOptional<z.ZodCoercedString<unknown>>;
                    logo: z.ZodOptional<z.ZodString>;
                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    keepCurrentActiveOrganization: z.ZodOptional<z.ZodBoolean>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                            name: string;
                            slug: string;
                            userId?: string | undefined;
                            logo?: string | undefined;
                            metadata?: Record<string, any> | undefined;
                            keepCurrentActiveOrganization?: boolean | undefined;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }>> extends true ? [better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    slug: z.ZodString;
                    userId: z.ZodOptional<z.ZodCoercedString<unknown>>;
                    logo: z.ZodOptional<z.ZodString>;
                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    keepCurrentActiveOrganization: z.ZodOptional<z.ZodBoolean>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                            name: string;
                            slug: string;
                            userId?: string | undefined;
                            logo?: string | undefined;
                            metadata?: Record<string, any> | undefined;
                            keepCurrentActiveOrganization?: boolean | undefined;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                name: string;
                slug: string;
                userId?: string | undefined;
                logo?: string | undefined;
                metadata?: Record<string, any> | undefined;
                keepCurrentActiveOrganization?: boolean | undefined;
            }> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }] : [((better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    slug: z.ZodString;
                    userId: z.ZodOptional<z.ZodCoercedString<unknown>>;
                    logo: z.ZodOptional<z.ZodString>;
                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    keepCurrentActiveOrganization: z.ZodOptional<z.ZodBoolean>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                            name: string;
                            slug: string;
                            userId?: string | undefined;
                            logo?: string | undefined;
                            metadata?: Record<string, any> | undefined;
                            keepCurrentActiveOrganization?: boolean | undefined;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                name: string;
                slug: string;
                userId?: string | undefined;
                logo?: string | undefined;
                metadata?: Record<string, any> | undefined;
                keepCurrentActiveOrganization?: boolean | undefined;
            }> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined)?]): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, false> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, false>)[K]; } : never) & {
                    metadata: Record<string, any> | undefined;
                    members: (({
                        id: string;
                        organizationId: string;
                        userId: string;
                        role: string;
                        createdAt: Date;
                    } & InferAdditionalFieldsFromPluginOptions<"member", O, false>) | undefined)[];
                }) | null;
            } : (({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, false> extends infer T_1 ? { [K in keyof T_1]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, false>)[K]; } : never) & {
                metadata: Record<string, any> | undefined;
                members: (({
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                } & InferAdditionalFieldsFromPluginOptions<"member", O, false>) | undefined)[];
            }) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    slug: z.ZodString;
                    userId: z.ZodOptional<z.ZodCoercedString<unknown>>;
                    logo: z.ZodOptional<z.ZodString>;
                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    keepCurrentActiveOrganization: z.ZodOptional<z.ZodBoolean>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                            name: string;
                            slug: string;
                            userId?: string | undefined;
                            logo?: string | undefined;
                            metadata?: Record<string, any> | undefined;
                            keepCurrentActiveOrganization?: boolean | undefined;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/create";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/update`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.updateOrganization`
         *
         * **client:**
         * `authClient.organization.update`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-update)
         */
        updateOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    data: {
                        name?: string;
                        slug?: string;
                        logo?: string;
                        metadata?: Record<string, any>;
                    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>;
                    organizationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) & {
                    metadata: Record<string, any> | undefined;
                }) | null;
            } : (({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) & {
                metadata: Record<string, any> | undefined;
            }) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    data: z.ZodObject<{
                        name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                        slug: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                        logo: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                        metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
                    }, z.core.$strip>;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                requireHeaders: true;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: {
                            data: {
                                name?: string;
                                slug?: string;
                                logo?: string;
                                metadata?: Record<string, any>;
                            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>;
                            organizationId: string;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/update";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/delete`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.deleteOrganization`
         *
         * **client:**
         * `authClient.organization.delete`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-delete)
         */
        deleteOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    organizationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) | null;
            } : ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    organizationId: z.ZodString;
                }, z.core.$strip>;
                requireHeaders: true;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "string";
                                            description: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/delete";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/set-active`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.setActiveOrganization`
         *
         * **client:**
         * `authClient.organization.setActive`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-set-active)
         */
        setActiveOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    organizationId?: string | null | undefined;
                    organizationSlug?: string | undefined;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (O["teams"] extends {
                    enabled: true;
                } ? {
                    members: InferMember<O>[];
                    invitations: InferInvitation<O>[];
                    teams: Team[];
                } & ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
                    members: InferMember<O>[];
                    invitations: InferInvitation<O>[];
                } & ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null;
            } : (O["teams"] extends {
                enabled: true;
            } ? {
                members: InferMember<O>[];
                invitations: InferInvitation<O>[];
                teams: Team[];
            } & ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_2 ? { [K in keyof T_2]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
                members: InferMember<O>[];
                invitations: InferInvitation<O>[];
            } & ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_3 ? { [K in keyof T_3]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    organizationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                    organizationSlug: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/set-active";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/get-full-organization`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.getFullOrganization`
         *
         * **client:**
         * `authClient.organization.getFullOrganization`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-get-full-organization)
         */
        getFullOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    organizationId?: string | undefined;
                    organizationSlug?: string | undefined;
                    membersLimit?: string | number | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (O["teams"] extends {
                    enabled: true;
                } ? {
                    members: InferMember<O>[];
                    invitations: InferInvitation<O>[];
                    teams: Team[];
                } & ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
                    members: InferMember<O>[];
                    invitations: InferInvitation<O>[];
                } & ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null;
            } : (O["teams"] extends {
                enabled: true;
            } ? {
                members: InferMember<O>[];
                invitations: InferInvitation<O>[];
                teams: Team[];
            } & ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_2 ? { [K in keyof T_2]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
                members: InferMember<O>[];
                invitations: InferInvitation<O>[];
            } & ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_3 ? { [K in keyof T_3]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null>;
            options: {
                method: "GET";
                query: z.ZodOptional<z.ZodObject<{
                    organizationId: z.ZodOptional<z.ZodString>;
                    organizationSlug: z.ZodOptional<z.ZodString>;
                    membersLimit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
                }, z.core.$strip>>;
                requireHeaders: true;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/get-full-organization";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/list`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listOrganizations`
         *
         * **client:**
         * `authClient.organization.list`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-list)
         */
        listOrganizations: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)[];
            } : ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)[]>;
            options: {
                method: "GET";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "array";
                                            items: {
                                                $ref: string;
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/list";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/invite-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.createInvitation`
         *
         * **client:**
         * `authClient.organization.inviteMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-invite-member)
         */
        createInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(...inputCtx: better_call.HasRequiredKeys<better_call.InputContext<"/organization/invite-member", {
                method: "POST";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                body: z.ZodObject<{
                    email: z.ZodString;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    resend: z.ZodOptional<z.ZodBoolean>;
                    teamId: z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodOptional<z.ZodArray<z.ZodString>>]>;
                }, z.core.$strip>;
                metadata: {
                    $Infer: {
                        body: {
                            email: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                            resend?: boolean;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string | string[];
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }>> extends true ? [better_call.InferBodyInput<{
                method: "POST";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                body: z.ZodObject<{
                    email: z.ZodString;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    resend: z.ZodOptional<z.ZodBoolean>;
                    teamId: z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodOptional<z.ZodArray<z.ZodString>>]>;
                }, z.core.$strip>;
                metadata: {
                    $Infer: {
                        body: {
                            email: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                            resend?: boolean;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string | string[];
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, {
                email: string;
                role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                organizationId?: string;
                resend?: boolean;
            } & (O extends {
                teams: {
                    enabled: true;
                };
            } ? {
                teamId?: string | string[];
            } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }] : [((better_call.InferBodyInput<{
                method: "POST";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                body: z.ZodObject<{
                    email: z.ZodString;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    resend: z.ZodOptional<z.ZodBoolean>;
                    teamId: z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodOptional<z.ZodArray<z.ZodString>>]>;
                }, z.core.$strip>;
                metadata: {
                    $Infer: {
                        body: {
                            email: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                            resend?: boolean;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string | string[];
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, {
                email: string;
                role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                organizationId?: string;
                resend?: boolean;
            } & (O extends {
                teams: {
                    enabled: true;
                };
            } ? {
                teamId?: string | string[];
            } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined)?]): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: InferInvitation<O>;
            } : InferInvitation<O>>;
            options: {
                method: "POST";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                body: z.ZodObject<{
                    email: z.ZodString;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    resend: z.ZodOptional<z.ZodBoolean>;
                    teamId: z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodOptional<z.ZodArray<z.ZodString>>]>;
                }, z.core.$strip>;
                metadata: {
                    $Infer: {
                        body: {
                            email: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                            resend?: boolean;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string | string[];
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/invite-member";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/cancel-invitation`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.cancelInvitation`
         *
         * **client:**
         * `authClient.organization.cancelInvitation`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-cancel-invitation)
         */
        cancelInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    invitationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: InferInvitation<O> | null;
            } : InferInvitation<O> | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    invitationId: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                openapi: {
                    description: string;
                    responses: {
                        "200": {
                            description: string;
                            content: {
                                "application/json": {
                                    schema: {
                                        type: string;
                                        properties: {
                                            invitation: {
                                                type: string;
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/cancel-invitation";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/accept-invitation`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.acceptInvitation`
         *
         * **client:**
         * `authClient.organization.acceptInvitation`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-accept-invitation)
         */
        acceptInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    invitationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    invitation: InferInvitation<O>;
                    member: {
                        id: string;
                        organizationId: string;
                        userId: string;
                        role: string;
                        createdAt: Date;
                    } & InferAdditionalFieldsFromPluginOptions<"member", O, false>;
                } | null;
            } : {
                invitation: InferInvitation<O>;
                member: {
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                } & InferAdditionalFieldsFromPluginOptions<"member", O, false>;
            } | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    invitationId: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                invitation: {
                                                    type: string;
                                                };
                                                member: {
                                                    type: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/accept-invitation";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/get-invitation`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.getInvitation`
         *
         * **client:**
         * `authClient.organization.getInvitation`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-get-invitation)
         */
        getInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query: {
                    id: string;
                };
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (O["teams"] extends {
                    enabled: true;
                } ? {
                    id: string;
                    organizationId: string;
                    email: string;
                    role: InferOrganizationRolesFromOption<O>;
                    status: InvitationStatus;
                    inviterId: string;
                    expiresAt: Date;
                    teamId?: string;
                } : {
                    id: string;
                    organizationId: string;
                    email: string;
                    role: InferOrganizationRolesFromOption<O>;
                    status: InvitationStatus;
                    inviterId: string;
                    expiresAt: Date;
                }) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false> & {
                    organizationName: ({
                        id: string;
                        name: string;
                        slug: string;
                        createdAt: Date;
                        logo?: string | null | undefined;
                        metadata?: any;
                    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)["name"];
                    organizationSlug: ({
                        id: string;
                        name: string;
                        slug: string;
                        createdAt: Date;
                        logo?: string | null | undefined;
                        metadata?: any;
                    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)["slug"];
                    inviterEmail: string;
                };
            } : (O["teams"] extends {
                enabled: true;
            } ? {
                id: string;
                organizationId: string;
                email: string;
                role: InferOrganizationRolesFromOption<O>;
                status: InvitationStatus;
                inviterId: string;
                expiresAt: Date;
                teamId?: string;
            } : {
                id: string;
                organizationId: string;
                email: string;
                role: InferOrganizationRolesFromOption<O>;
                status: InvitationStatus;
                inviterId: string;
                expiresAt: Date;
            }) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false> & {
                organizationName: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)["name"];
                organizationSlug: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)["slug"];
                inviterEmail: string;
            }>;
            options: {
                method: "GET";
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                requireHeaders: true;
                query: z.ZodObject<{
                    id: z.ZodString;
                }, z.core.$strip>;
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                                organizationName: {
                                                    type: string;
                                                };
                                                organizationSlug: {
                                                    type: string;
                                                };
                                                inviterEmail: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/get-invitation";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/reject-invitation`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.rejectInvitation`
         *
         * **client:**
         * `authClient.organization.rejectInvitation`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-reject-invitation)
         */
        rejectInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    invitationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    invitation: {
                        id: string;
                        organizationId: string;
                        email: string;
                        role: "owner" | "member" | "admin";
                        status: InvitationStatus;
                        inviterId: string;
                        expiresAt: Date;
                    } | null;
                    member: null;
                };
            } : {
                invitation: {
                    id: string;
                    organizationId: string;
                    email: string;
                    role: "owner" | "member" | "admin";
                    status: InvitationStatus;
                    inviterId: string;
                    expiresAt: Date;
                } | null;
                member: null;
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    invitationId: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                invitation: {
                                                    type: string;
                                                };
                                                member: {
                                                    type: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/reject-invitation";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/list-invitations`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listInvitations`
         *
         * **client:**
         * `authClient.organization.listInvitations`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-list-invitations)
         */
        listInvitations: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    organizationId?: string | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: InferInvitation<O>[];
            } : InferInvitation<O>[]>;
            options: {
                method: "GET";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                query: z.ZodOptional<z.ZodObject<{
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            } & {
                use: any[];
            };
            path: "/organization/list-invitations";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/get-active-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.getActiveMember`
         *
         * **client:**
         * `authClient.organization.getActiveMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-get-active-member)
         */
        getActiveMember: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    user: {
                        id: string;
                        name: string;
                        email: string;
                        image: string | null | undefined;
                    };
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                } | null;
            } : {
                user: {
                    id: string;
                    name: string;
                    email: string;
                    image: string | null | undefined;
                };
                id: string;
                organizationId: string;
                userId: string;
                role: string;
                createdAt: Date;
            } | null>;
            options: {
                method: "GET";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                requireHeaders: true;
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                userId: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/get-active-member";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/check-slug`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.checkOrganizationSlug`
         *
         * **client:**
         * `authClient.organization.checkSlug`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-check-slug)
         */
        checkOrganizationSlug: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    slug: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    status: boolean;
                };
            } : {
                status: boolean;
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    slug: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            userId: string;
                            expiresAt: Date;
                            createdAt: Date;
                            updatedAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            email: string;
                            emailVerified: boolean;
                            name: string;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };
                    } | null;
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/check-slug";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/add-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.addMember`
         *
         * **client:**
         * `authClient.organization.addMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-add-member)
         */
        addMember: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(...inputCtx: better_call.HasRequiredKeys<better_call.InputContext<"/organization/add-member", {
                method: "POST";
                body: z.ZodObject<{
                    userId: z.ZodCoercedString<unknown>;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    teamId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    SERVER_ONLY: true;
                    $Infer: {
                        body: {
                            userId: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string;
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>;
                    };
                };
            } & {
                use: any[];
            }>> extends true ? [better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    userId: z.ZodCoercedString<unknown>;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    teamId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    SERVER_ONLY: true;
                    $Infer: {
                        body: {
                            userId: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string;
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>;
                    };
                };
            } & {
                use: any[];
            }, {
                userId: string;
                role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                organizationId?: string;
            } & (O extends {
                teams: {
                    enabled: true;
                };
            } ? {
                teamId?: string;
            } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }] : [((better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    userId: z.ZodCoercedString<unknown>;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    teamId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    SERVER_ONLY: true;
                    $Infer: {
                        body: {
                            userId: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string;
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>;
                    };
                };
            } & {
                use: any[];
            }, {
                userId: string;
                role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                organizationId?: string;
            } & (O extends {
                teams: {
                    enabled: true;
                };
            } ? {
                teamId?: string;
            } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined)?]): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: ({
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                } & InferAdditionalFieldsFromPluginOptions<"member", O, false>) | null;
            } : ({
                id: string;
                organizationId: string;
                userId: string;
                role: string;
                createdAt: Date;
            } & InferAdditionalFieldsFromPluginOptions<"member", O, false>) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    userId: z.ZodCoercedString<unknown>;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    teamId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    SERVER_ONLY: true;
                    $Infer: {
                        body: {
                            userId: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string;
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>;
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/add-member";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/remove-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.removeMember`
         *
         * **client:**
         * `authClient.organization.removeMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-remove-member)
         */
        removeMember: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    memberIdOrEmail: string;
                    organizationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    member: {
                        id: string;
                        organizationId: string;
                        userId: string;
                        role: string;
                        createdAt: Date;
                    };
                } | null;
            } : {
                member: {
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                };
            } | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    memberIdOrEmail: z.ZodString;
                    organizationId: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                member: {
                                                    type: string;
                                                    properties: {
                                                        id: {
                                                            type: string;
                                                        };
                                                        userId: {
                                                            type: string;
                                                        };
                                                        organizationId: {
                                                            type: string;
                                                        };
                                                        role: {
                                                            type: string;
                                                        };
                                                    };
                                                    required: string[];
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/remove-member";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/update-member-role`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.updateMemberRole`
         *
         * **client:**
         * `authClient.organization.updateMemberRole`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-update-member-role)
         */
        updateMemberRole: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                    memberId: string;
                    organizationId?: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    id: string;
                    organizationId: string;
                    role: "owner" | "member" | "admin";
                    createdAt: Date;
                    userId: string;
                    user: {
                        email: string;
                        name: string;
                        image?: string;
                    };
                };
            } : {
                id: string;
                organizationId: string;
                role: "owner" | "member" | "admin";
                createdAt: Date;
                userId: string;
                user: {
                    email: string;
                    name: string;
                    image?: string;
                };
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    memberId: z.ZodString;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    $Infer: {
                        body: {
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            memberId: string;
                            organizationId?: string;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                member: {
                                                    type: string;
                                                    properties: {
                                                        id: {
                                                            type: string;
                                                        };
                                                        userId: {
                                                            type: string;
                                                        };
                                                        organizationId: {
                                                            type: string;
                                                        };
                                                        role: {
                                                            type: string;
                                                        };
                                                    };
                                                    required: string[];
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/update-member-role";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/leave`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.leaveOrganization`
         *
         * **client:**
         * `authClient.organization.leave`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-leave)
         */
        leaveOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    organizationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    user: {
                        id: string;
                        name: string;
                        email: string;
                        image: string | null | undefined;
                    };
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                };
            } : {
                user: {
                    id: string;
                    name: string;
                    email: string;
                    image: string | null | undefined;
                };
                id: string;
                organizationId: string;
                userId: string;
                role: string;
                createdAt: Date;
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    organizationId: z.ZodString;
                }, z.core.$strip>;
                requireHeaders: true;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            userId: string;
                            expiresAt: Date;
                            createdAt: Date;
                            updatedAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            email: string;
                            emailVerified: boolean;
                            name: string;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };
                    };
                }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/leave";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/list-members`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listMembers`
         *
         * **client:**
         * `authClient.organization.listMembers`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-list-members)
         */
        listUserInvitations: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    email?: string | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: InferInvitation<O>[];
            } : InferInvitation<O>[]>;
            options: {
                method: "GET";
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                query: z.ZodOptional<z.ZodObject<{
                    email: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            } & {
                use: any[];
            };
            path: "/organization/list-user-invitations";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/list-members`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listMembers`
         *
         * **client:**
         * `authClient.organization.listMembers`
         */
        listMembers: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    limit?: string | number | undefined;
                    offset?: string | number | undefined;
                    sortBy?: string | undefined;
                    sortDirection?: "asc" | "desc" | undefined;
                    filterField?: string | undefined;
                    filterValue?: string | number | boolean | undefined;
                    filterOperator?: "lt" | "eq" | "ne" | "lte" | "gt" | "gte" | "contains" | undefined;
                    organizationId?: string | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    members: {
                        user: {
                            id: string;
                            name: string;
                            email: string;
                            image: string | null | undefined;
                        };
                        id: string;
                        organizationId: string;
                        userId: string;
                        role: string;
                        createdAt: Date;
                    }[];
                    total: number;
                };
            } : {
                members: {
                    user: {
                        id: string;
                        name: string;
                        email: string;
                        image: string | null | undefined;
                    };
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                }[];
                total: number;
            }>;
            options: {
                method: "GET";
                query: z.ZodOptional<z.ZodObject<{
                    limit: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
                    offset: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
                    sortBy: z.ZodOptional<z.ZodString>;
                    sortDirection: z.ZodOptional<z.ZodEnum<{
                        asc: "asc";
                        desc: "desc";
                    }>>;
                    filterField: z.ZodOptional<z.ZodString>;
                    filterValue: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodBoolean]>>;
                    filterOperator: z.ZodOptional<z.ZodEnum<{
                        lt: "lt";
                        eq: "eq";
                        ne: "ne";
                        lte: "lte";
                        gt: "gt";
                        gte: "gte";
                        contains: "contains";
                    }>>;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/list-members";
        };
    } : {
        /**
         * ### Endpoint
         *
         * POST `/organization/create`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.createOrganization`
         *
         * **client:**
         * `authClient.organization.create`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-create)
         */
        createOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(...inputCtx: better_call.HasRequiredKeys<better_call.InputContext<"/organization/create", {
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    slug: z.ZodString;
                    userId: z.ZodOptional<z.ZodCoercedString<unknown>>;
                    logo: z.ZodOptional<z.ZodString>;
                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    keepCurrentActiveOrganization: z.ZodOptional<z.ZodBoolean>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                            name: string;
                            slug: string;
                            userId?: string | undefined;
                            logo?: string | undefined;
                            metadata?: Record<string, any> | undefined;
                            keepCurrentActiveOrganization?: boolean | undefined;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }>> extends true ? [better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    slug: z.ZodString;
                    userId: z.ZodOptional<z.ZodCoercedString<unknown>>;
                    logo: z.ZodOptional<z.ZodString>;
                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    keepCurrentActiveOrganization: z.ZodOptional<z.ZodBoolean>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                            name: string;
                            slug: string;
                            userId?: string | undefined;
                            logo?: string | undefined;
                            metadata?: Record<string, any> | undefined;
                            keepCurrentActiveOrganization?: boolean | undefined;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                name: string;
                slug: string;
                userId?: string | undefined;
                logo?: string | undefined;
                metadata?: Record<string, any> | undefined;
                keepCurrentActiveOrganization?: boolean | undefined;
            }> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }] : [((better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    slug: z.ZodString;
                    userId: z.ZodOptional<z.ZodCoercedString<unknown>>;
                    logo: z.ZodOptional<z.ZodString>;
                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    keepCurrentActiveOrganization: z.ZodOptional<z.ZodBoolean>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                            name: string;
                            slug: string;
                            userId?: string | undefined;
                            logo?: string | undefined;
                            metadata?: Record<string, any> | undefined;
                            keepCurrentActiveOrganization?: boolean | undefined;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                name: string;
                slug: string;
                userId?: string | undefined;
                logo?: string | undefined;
                metadata?: Record<string, any> | undefined;
                keepCurrentActiveOrganization?: boolean | undefined;
            }> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined)?]): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, false> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, false>)[K]; } : never) & {
                    metadata: Record<string, any> | undefined;
                    members: (({
                        id: string;
                        organizationId: string;
                        userId: string;
                        role: string;
                        createdAt: Date;
                    } & InferAdditionalFieldsFromPluginOptions<"member", O, false>) | undefined)[];
                }) | null;
            } : (({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, false> extends infer T_1 ? { [K in keyof T_1]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, false>)[K]; } : never) & {
                metadata: Record<string, any> | undefined;
                members: (({
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                } & InferAdditionalFieldsFromPluginOptions<"member", O, false>) | undefined)[];
            }) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    name: z.ZodString;
                    slug: z.ZodString;
                    userId: z.ZodOptional<z.ZodCoercedString<unknown>>;
                    logo: z.ZodOptional<z.ZodString>;
                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    keepCurrentActiveOrganization: z.ZodOptional<z.ZodBoolean>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: InferAdditionalFieldsFromPluginOptions<"organization", O, true> & {
                            name: string;
                            slug: string;
                            userId?: string | undefined;
                            logo?: string | undefined;
                            metadata?: Record<string, any> | undefined;
                            keepCurrentActiveOrganization?: boolean | undefined;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/create";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/update`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.updateOrganization`
         *
         * **client:**
         * `authClient.organization.update`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-update)
         */
        updateOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    data: {
                        name?: string;
                        slug?: string;
                        logo?: string;
                        metadata?: Record<string, any>;
                    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>;
                    organizationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) & {
                    metadata: Record<string, any> | undefined;
                }) | null;
            } : (({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) & {
                metadata: Record<string, any> | undefined;
            }) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    data: z.ZodObject<{
                        name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                        slug: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                        logo: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                        metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
                    }, z.core.$strip>;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                requireHeaders: true;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    $Infer: {
                        body: {
                            data: {
                                name?: string;
                                slug?: string;
                                logo?: string;
                                metadata?: Record<string, any>;
                            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>;
                            organizationId: string;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/update";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/delete`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.deleteOrganization`
         *
         * **client:**
         * `authClient.organization.delete`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-delete)
         */
        deleteOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    organizationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) | null;
            } : ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    organizationId: z.ZodString;
                }, z.core.$strip>;
                requireHeaders: true;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "string";
                                            description: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/delete";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/set-active`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.setActiveOrganization`
         *
         * **client:**
         * `authClient.organization.setActive`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-set-active)
         */
        setActiveOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    organizationId?: string | null | undefined;
                    organizationSlug?: string | undefined;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (O["teams"] extends {
                    enabled: true;
                } ? {
                    members: InferMember<O>[];
                    invitations: InferInvitation<O>[];
                    teams: Team[];
                } & ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
                    members: InferMember<O>[];
                    invitations: InferInvitation<O>[];
                } & ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null;
            } : (O["teams"] extends {
                enabled: true;
            } ? {
                members: InferMember<O>[];
                invitations: InferInvitation<O>[];
                teams: Team[];
            } & ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_2 ? { [K in keyof T_2]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
                members: InferMember<O>[];
                invitations: InferInvitation<O>[];
            } & ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_3 ? { [K in keyof T_3]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    organizationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                    organizationSlug: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/set-active";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/get-full-organization`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.getFullOrganization`
         *
         * **client:**
         * `authClient.organization.getFullOrganization`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-get-full-organization)
         */
        getFullOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    organizationId?: string | undefined;
                    organizationSlug?: string | undefined;
                    membersLimit?: string | number | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (O["teams"] extends {
                    enabled: true;
                } ? {
                    members: InferMember<O>[];
                    invitations: InferInvitation<O>[];
                    teams: Team[];
                } & ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
                    members: InferMember<O>[];
                    invitations: InferInvitation<O>[];
                } & ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null;
            } : (O["teams"] extends {
                enabled: true;
            } ? {
                members: InferMember<O>[];
                invitations: InferInvitation<O>[];
                teams: Team[];
            } & ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_2 ? { [K in keyof T_2]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never) : {
                members: InferMember<O>[];
                invitations: InferInvitation<O>[];
            } & ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_3 ? { [K in keyof T_3]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)) | null>;
            options: {
                method: "GET";
                query: z.ZodOptional<z.ZodObject<{
                    organizationId: z.ZodOptional<z.ZodString>;
                    organizationSlug: z.ZodOptional<z.ZodString>;
                    membersLimit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>;
                }, z.core.$strip>>;
                requireHeaders: true;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            description: string;
                                            $ref: string;
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/get-full-organization";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/list`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listOrganizations`
         *
         * **client:**
         * `authClient.organization.list`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-list)
         */
        listOrganizations: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T ? { [K in keyof T]: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)[];
            } : ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true> extends infer T_1 ? { [K in keyof T_1]: ({
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)[K]; } : never)[]>;
            options: {
                method: "GET";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "array";
                                            items: {
                                                $ref: string;
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/list";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/invite-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.createInvitation`
         *
         * **client:**
         * `authClient.organization.inviteMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-invite-member)
         */
        createInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(...inputCtx: better_call.HasRequiredKeys<better_call.InputContext<"/organization/invite-member", {
                method: "POST";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                body: z.ZodObject<{
                    email: z.ZodString;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    resend: z.ZodOptional<z.ZodBoolean>;
                    teamId: z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodOptional<z.ZodArray<z.ZodString>>]>;
                }, z.core.$strip>;
                metadata: {
                    $Infer: {
                        body: {
                            email: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                            resend?: boolean;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string | string[];
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }>> extends true ? [better_call.InferBodyInput<{
                method: "POST";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                body: z.ZodObject<{
                    email: z.ZodString;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    resend: z.ZodOptional<z.ZodBoolean>;
                    teamId: z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodOptional<z.ZodArray<z.ZodString>>]>;
                }, z.core.$strip>;
                metadata: {
                    $Infer: {
                        body: {
                            email: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                            resend?: boolean;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string | string[];
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, {
                email: string;
                role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                organizationId?: string;
                resend?: boolean;
            } & (O extends {
                teams: {
                    enabled: true;
                };
            } ? {
                teamId?: string | string[];
            } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }] : [((better_call.InferBodyInput<{
                method: "POST";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                body: z.ZodObject<{
                    email: z.ZodString;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    resend: z.ZodOptional<z.ZodBoolean>;
                    teamId: z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodOptional<z.ZodArray<z.ZodString>>]>;
                }, z.core.$strip>;
                metadata: {
                    $Infer: {
                        body: {
                            email: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                            resend?: boolean;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string | string[];
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            }, {
                email: string;
                role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                organizationId?: string;
                resend?: boolean;
            } & (O extends {
                teams: {
                    enabled: true;
                };
            } ? {
                teamId?: string | string[];
            } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined)?]): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: InferInvitation<O>;
            } : InferInvitation<O>>;
            options: {
                method: "POST";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                body: z.ZodObject<{
                    email: z.ZodString;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    resend: z.ZodOptional<z.ZodBoolean>;
                    teamId: z.ZodUnion<readonly [z.ZodOptional<z.ZodString>, z.ZodOptional<z.ZodArray<z.ZodString>>]>;
                }, z.core.$strip>;
                metadata: {
                    $Infer: {
                        body: {
                            email: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                            resend?: boolean;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string | string[];
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false>;
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/invite-member";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/cancel-invitation`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.cancelInvitation`
         *
         * **client:**
         * `authClient.organization.cancelInvitation`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-cancel-invitation)
         */
        cancelInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    invitationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: InferInvitation<O> | null;
            } : InferInvitation<O> | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    invitationId: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                openapi: {
                    description: string;
                    responses: {
                        "200": {
                            description: string;
                            content: {
                                "application/json": {
                                    schema: {
                                        type: string;
                                        properties: {
                                            invitation: {
                                                type: string;
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/cancel-invitation";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/accept-invitation`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.acceptInvitation`
         *
         * **client:**
         * `authClient.organization.acceptInvitation`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-accept-invitation)
         */
        acceptInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    invitationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    invitation: InferInvitation<O>;
                    member: {
                        id: string;
                        organizationId: string;
                        userId: string;
                        role: string;
                        createdAt: Date;
                    } & InferAdditionalFieldsFromPluginOptions<"member", O, false>;
                } | null;
            } : {
                invitation: InferInvitation<O>;
                member: {
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                } & InferAdditionalFieldsFromPluginOptions<"member", O, false>;
            } | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    invitationId: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                invitation: {
                                                    type: string;
                                                };
                                                member: {
                                                    type: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/accept-invitation";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/get-invitation`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.getInvitation`
         *
         * **client:**
         * `authClient.organization.getInvitation`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-get-invitation)
         */
        getInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query: {
                    id: string;
                };
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: (O["teams"] extends {
                    enabled: true;
                } ? {
                    id: string;
                    organizationId: string;
                    email: string;
                    role: InferOrganizationRolesFromOption<O>;
                    status: InvitationStatus;
                    inviterId: string;
                    expiresAt: Date;
                    teamId?: string;
                } : {
                    id: string;
                    organizationId: string;
                    email: string;
                    role: InferOrganizationRolesFromOption<O>;
                    status: InvitationStatus;
                    inviterId: string;
                    expiresAt: Date;
                }) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false> & {
                    organizationName: ({
                        id: string;
                        name: string;
                        slug: string;
                        createdAt: Date;
                        logo?: string | null | undefined;
                        metadata?: any;
                    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)["name"];
                    organizationSlug: ({
                        id: string;
                        name: string;
                        slug: string;
                        createdAt: Date;
                        logo?: string | null | undefined;
                        metadata?: any;
                    } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)["slug"];
                    inviterEmail: string;
                };
            } : (O["teams"] extends {
                enabled: true;
            } ? {
                id: string;
                organizationId: string;
                email: string;
                role: InferOrganizationRolesFromOption<O>;
                status: InvitationStatus;
                inviterId: string;
                expiresAt: Date;
                teamId?: string;
            } : {
                id: string;
                organizationId: string;
                email: string;
                role: InferOrganizationRolesFromOption<O>;
                status: InvitationStatus;
                inviterId: string;
                expiresAt: Date;
            }) & InferAdditionalFieldsFromPluginOptions<"invitation", O, false> & {
                organizationName: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)["name"];
                organizationSlug: ({
                    id: string;
                    name: string;
                    slug: string;
                    createdAt: Date;
                    logo?: string | null | undefined;
                    metadata?: any;
                } & InferAdditionalFieldsFromPluginOptions<"organization", O, true>)["slug"];
                inviterEmail: string;
            }>;
            options: {
                method: "GET";
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                requireHeaders: true;
                query: z.ZodObject<{
                    id: z.ZodString;
                }, z.core.$strip>;
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                email: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                inviterId: {
                                                    type: string;
                                                };
                                                status: {
                                                    type: string;
                                                };
                                                expiresAt: {
                                                    type: string;
                                                };
                                                organizationName: {
                                                    type: string;
                                                };
                                                organizationSlug: {
                                                    type: string;
                                                };
                                                inviterEmail: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/get-invitation";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/reject-invitation`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.rejectInvitation`
         *
         * **client:**
         * `authClient.organization.rejectInvitation`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-reject-invitation)
         */
        rejectInvitation: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    invitationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    invitation: {
                        id: string;
                        organizationId: string;
                        email: string;
                        role: "owner" | "member" | "admin";
                        status: InvitationStatus;
                        inviterId: string;
                        expiresAt: Date;
                    } | null;
                    member: null;
                };
            } : {
                invitation: {
                    id: string;
                    organizationId: string;
                    email: string;
                    role: "owner" | "member" | "admin";
                    status: InvitationStatus;
                    inviterId: string;
                    expiresAt: Date;
                } | null;
                member: null;
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    invitationId: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                invitation: {
                                                    type: string;
                                                };
                                                member: {
                                                    type: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/reject-invitation";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/list-invitations`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listInvitations`
         *
         * **client:**
         * `authClient.organization.listInvitations`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-list-invitations)
         */
        listInvitations: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    organizationId?: string | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: InferInvitation<O>[];
            } : InferInvitation<O>[]>;
            options: {
                method: "GET";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                query: z.ZodOptional<z.ZodObject<{
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            } & {
                use: any[];
            };
            path: "/organization/list-invitations";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/get-active-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.getActiveMember`
         *
         * **client:**
         * `authClient.organization.getActiveMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-get-active-member)
         */
        getActiveMember: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    user: {
                        id: string;
                        name: string;
                        email: string;
                        image: string | null | undefined;
                    };
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                } | null;
            } : {
                user: {
                    id: string;
                    name: string;
                    email: string;
                    image: string | null | undefined;
                };
                id: string;
                organizationId: string;
                userId: string;
                role: string;
                createdAt: Date;
            } | null>;
            options: {
                method: "GET";
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                requireHeaders: true;
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                id: {
                                                    type: string;
                                                };
                                                userId: {
                                                    type: string;
                                                };
                                                organizationId: {
                                                    type: string;
                                                };
                                                role: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/get-active-member";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/check-slug`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.checkOrganizationSlug`
         *
         * **client:**
         * `authClient.organization.checkSlug`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-check-slug)
         */
        checkOrganizationSlug: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    slug: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    status: boolean;
                };
            } : {
                status: boolean;
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    slug: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            userId: string;
                            expiresAt: Date;
                            createdAt: Date;
                            updatedAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            email: string;
                            emailVerified: boolean;
                            name: string;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };
                    } | null;
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/check-slug";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/add-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.addMember`
         *
         * **client:**
         * `authClient.organization.addMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-add-member)
         */
        addMember: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(...inputCtx: better_call.HasRequiredKeys<better_call.InputContext<"/organization/add-member", {
                method: "POST";
                body: z.ZodObject<{
                    userId: z.ZodCoercedString<unknown>;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    teamId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    SERVER_ONLY: true;
                    $Infer: {
                        body: {
                            userId: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string;
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>;
                    };
                };
            } & {
                use: any[];
            }>> extends true ? [better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    userId: z.ZodCoercedString<unknown>;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    teamId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    SERVER_ONLY: true;
                    $Infer: {
                        body: {
                            userId: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string;
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>;
                    };
                };
            } & {
                use: any[];
            }, {
                userId: string;
                role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                organizationId?: string;
            } & (O extends {
                teams: {
                    enabled: true;
                };
            } ? {
                teamId?: string;
            } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }] : [((better_call.InferBodyInput<{
                method: "POST";
                body: z.ZodObject<{
                    userId: z.ZodCoercedString<unknown>;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    teamId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    SERVER_ONLY: true;
                    $Infer: {
                        body: {
                            userId: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string;
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>;
                    };
                };
            } & {
                use: any[];
            }, {
                userId: string;
                role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                organizationId?: string;
            } & (O extends {
                teams: {
                    enabled: true;
                };
            } ? {
                teamId?: string;
            } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>> & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined)?]): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: ({
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                } & InferAdditionalFieldsFromPluginOptions<"member", O, false>) | null;
            } : ({
                id: string;
                organizationId: string;
                userId: string;
                role: string;
                createdAt: Date;
            } & InferAdditionalFieldsFromPluginOptions<"member", O, false>) | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    userId: z.ZodCoercedString<unknown>;
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    organizationId: z.ZodOptional<z.ZodString>;
                    teamId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                metadata: {
                    SERVER_ONLY: true;
                    $Infer: {
                        body: {
                            userId: string;
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            organizationId?: string;
                        } & (O extends {
                            teams: {
                                enabled: true;
                            };
                        } ? {
                            teamId?: string;
                        } : {}) & InferAdditionalFieldsFromPluginOptions<"member", O, true>;
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/add-member";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/remove-member`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.removeMember`
         *
         * **client:**
         * `authClient.organization.removeMember`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-remove-member)
         */
        removeMember: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    memberIdOrEmail: string;
                    organizationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    member: {
                        id: string;
                        organizationId: string;
                        userId: string;
                        role: string;
                        createdAt: Date;
                    };
                } | null;
            } : {
                member: {
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                };
            } | null>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    memberIdOrEmail: z.ZodString;
                    organizationId: z.ZodString;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                member: {
                                                    type: string;
                                                    properties: {
                                                        id: {
                                                            type: string;
                                                        };
                                                        userId: {
                                                            type: string;
                                                        };
                                                        organizationId: {
                                                            type: string;
                                                        };
                                                        role: {
                                                            type: string;
                                                        };
                                                    };
                                                    required: string[];
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/remove-member";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/update-member-role`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.updateMemberRole`
         *
         * **client:**
         * `authClient.organization.updateMemberRole`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-update-member-role)
         */
        updateMemberRole: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                    memberId: string;
                    organizationId?: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    id: string;
                    organizationId: string;
                    role: "owner" | "member" | "admin";
                    createdAt: Date;
                    userId: string;
                    user: {
                        email: string;
                        name: string;
                        image?: string;
                    };
                };
            } : {
                id: string;
                organizationId: string;
                role: "owner" | "member" | "admin";
                createdAt: Date;
                userId: string;
                user: {
                    email: string;
                    name: string;
                    image?: string;
                };
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    role: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
                    memberId: z.ZodString;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
                metadata: {
                    $Infer: {
                        body: {
                            role: InferOrganizationRolesFromOption<O> | InferOrganizationRolesFromOption<O>[];
                            memberId: string;
                            organizationId?: string;
                        };
                    };
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                member: {
                                                    type: string;
                                                    properties: {
                                                        id: {
                                                            type: string;
                                                        };
                                                        userId: {
                                                            type: string;
                                                        };
                                                        organizationId: {
                                                            type: string;
                                                        };
                                                        role: {
                                                            type: string;
                                                        };
                                                    };
                                                    required: string[];
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/update-member-role";
        };
        /**
         * ### Endpoint
         *
         * POST `/organization/leave`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.leaveOrganization`
         *
         * **client:**
         * `authClient.organization.leave`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-leave)
         */
        leaveOrganization: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    organizationId: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    user: {
                        id: string;
                        name: string;
                        email: string;
                        image: string | null | undefined;
                    };
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                };
            } : {
                user: {
                    id: string;
                    name: string;
                    email: string;
                    image: string | null | undefined;
                };
                id: string;
                organizationId: string;
                userId: string;
                role: string;
                createdAt: Date;
            }>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    organizationId: z.ZodString;
                }, z.core.$strip>;
                requireHeaders: true;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            userId: string;
                            expiresAt: Date;
                            createdAt: Date;
                            updatedAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            email: string;
                            emailVerified: boolean;
                            name: string;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };
                    };
                }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/leave";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/list-members`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listMembers`
         *
         * **client:**
         * `authClient.organization.listMembers`
         *
         * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/organization#api-method-organization-list-members)
         */
        listUserInvitations: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    email?: string | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: InferInvitation<O>[];
            } : InferInvitation<O>[]>;
            options: {
                method: "GET";
                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>)[];
                query: z.ZodOptional<z.ZodObject<{
                    email: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            } & {
                use: any[];
            };
            path: "/organization/list-user-invitations";
        };
        /**
         * ### Endpoint
         *
         * GET `/organization/list-members`
         *
         * ### API Methods
         *
         * **server:**
         * `auth.api.listMembers`
         *
         * **client:**
         * `authClient.organization.listMembers`
         */
        listMembers: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
                body?: undefined;
            } & {
                method?: "GET" | undefined;
            } & {
                query?: {
                    limit?: string | number | undefined;
                    offset?: string | number | undefined;
                    sortBy?: string | undefined;
                    sortDirection?: "asc" | "desc" | undefined;
                    filterField?: string | undefined;
                    filterValue?: string | number | boolean | undefined;
                    filterOperator?: "lt" | "eq" | "ne" | "lte" | "gt" | "gte" | "contains" | undefined;
                    organizationId?: string | undefined;
                } | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    members: {
                        user: {
                            id: string;
                            name: string;
                            email: string;
                            image: string | null | undefined;
                        };
                        id: string;
                        organizationId: string;
                        userId: string;
                        role: string;
                        createdAt: Date;
                    }[];
                    total: number;
                };
            } : {
                members: {
                    user: {
                        id: string;
                        name: string;
                        email: string;
                        image: string | null | undefined;
                    };
                    id: string;
                    organizationId: string;
                    userId: string;
                    role: string;
                    createdAt: Date;
                }[];
                total: number;
            }>;
            options: {
                method: "GET";
                query: z.ZodOptional<z.ZodObject<{
                    limit: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
                    offset: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
                    sortBy: z.ZodOptional<z.ZodString>;
                    sortDirection: z.ZodOptional<z.ZodEnum<{
                        asc: "asc";
                        desc: "desc";
                    }>>;
                    filterField: z.ZodOptional<z.ZodString>;
                    filterValue: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodBoolean]>>;
                    filterOperator: z.ZodOptional<z.ZodEnum<{
                        lt: "lt";
                        eq: "eq";
                        ne: "ne";
                        lte: "lte";
                        gt: "gt";
                        gte: "gte";
                        contains: "contains";
                    }>>;
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                use: (((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                    orgOptions: OrganizationOptions;
                    roles: typeof defaultRoles & {
                        [key: string]: Role<{}>;
                    };
                    getSession: (context: GenericEndpointContext) => Promise<{
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    }>;
                }>) | ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>))[];
            } & {
                use: any[];
            };
            path: "/organization/list-members";
        };
    }) & {
        hasPermission: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: ({
                    /**
                     * @deprecated Use `permissions` instead
                     */
                    permission: { [key in keyof (O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                        readonly organization: readonly ["update", "delete"];
                        readonly member: readonly ["create", "update", "delete"];
                        readonly invitation: readonly ["create", "cancel"];
                        readonly team: readonly ["create", "update", "delete"];
                    })]?: ((O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                        readonly organization: readonly ["update", "delete"];
                        readonly member: readonly ["create", "update", "delete"];
                        readonly invitation: readonly ["create", "cancel"];
                        readonly team: readonly ["create", "update", "delete"];
                    })[key] extends readonly unknown[] ? (O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                        readonly organization: readonly ["update", "delete"];
                        readonly member: readonly ["create", "update", "delete"];
                        readonly invitation: readonly ["create", "cancel"];
                        readonly team: readonly ["create", "update", "delete"];
                    })[key][number] : never)[] | undefined; };
                    permissions?: never;
                } | {
                    permissions: { [key in keyof (O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                        readonly organization: readonly ["update", "delete"];
                        readonly member: readonly ["create", "update", "delete"];
                        readonly invitation: readonly ["create", "cancel"];
                        readonly team: readonly ["create", "update", "delete"];
                    })]?: ((O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                        readonly organization: readonly ["update", "delete"];
                        readonly member: readonly ["create", "update", "delete"];
                        readonly invitation: readonly ["create", "cancel"];
                        readonly team: readonly ["create", "update", "delete"];
                    })[key] extends readonly unknown[] ? (O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                        readonly organization: readonly ["update", "delete"];
                        readonly member: readonly ["create", "update", "delete"];
                        readonly invitation: readonly ["create", "cancel"];
                        readonly team: readonly ["create", "update", "delete"];
                    })[key][number] : never)[] | undefined; };
                    permission?: never;
                }) & {
                    organizationId?: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: better_call.Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    error: null;
                    success: boolean;
                };
            } : {
                error: null;
                success: boolean;
            }>;
            options: {
                method: "POST";
                requireHeaders: true;
                body: z.ZodIntersection<z.ZodObject<{
                    organizationId: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
                    permission: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
                    permissions: z.ZodUndefined;
                }, z.core.$strip>, z.ZodObject<{
                    permission: z.ZodUndefined;
                    permissions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
                }, z.core.$strip>]>>;
                use: ((inputContext: better_call.MiddlewareInputContext<{
                    use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
                        session: {
                            session: Record<string, any> & {
                                id: string;
                                userId: string;
                                expiresAt: Date;
                                createdAt: Date;
                                updatedAt: Date;
                                token: string;
                                ipAddress?: string | null | undefined;
                                userAgent?: string | null | undefined;
                            };
                            user: Record<string, any> & {
                                id: string;
                                email: string;
                                emailVerified: boolean;
                                name: string;
                                createdAt: Date;
                                updatedAt: Date;
                                image?: string | null | undefined;
                            };
                        };
                    }>)[];
                }>) => Promise<{
                    session: {
                        session: Session & {
                            activeTeamId?: string;
                            activeOrganizationId?: string;
                        };
                        user: User;
                    };
                }>)[];
                metadata: {
                    $Infer: {
                        body: ({
                            /**
                             * @deprecated Use `permissions` instead
                             */
                            permission: { [key in keyof (O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                                readonly organization: readonly ["update", "delete"];
                                readonly member: readonly ["create", "update", "delete"];
                                readonly invitation: readonly ["create", "cancel"];
                                readonly team: readonly ["create", "update", "delete"];
                            })]?: ((O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                                readonly organization: readonly ["update", "delete"];
                                readonly member: readonly ["create", "update", "delete"];
                                readonly invitation: readonly ["create", "cancel"];
                                readonly team: readonly ["create", "update", "delete"];
                            })[key] extends readonly unknown[] ? (O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                                readonly organization: readonly ["update", "delete"];
                                readonly member: readonly ["create", "update", "delete"];
                                readonly invitation: readonly ["create", "cancel"];
                                readonly team: readonly ["create", "update", "delete"];
                            })[key][number] : never)[] | undefined; };
                            permissions?: never;
                        } | {
                            permissions: { [key in keyof (O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                                readonly organization: readonly ["update", "delete"];
                                readonly member: readonly ["create", "update", "delete"];
                                readonly invitation: readonly ["create", "cancel"];
                                readonly team: readonly ["create", "update", "delete"];
                            })]?: ((O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                                readonly organization: readonly ["update", "delete"];
                                readonly member: readonly ["create", "update", "delete"];
                                readonly invitation: readonly ["create", "cancel"];
                                readonly team: readonly ["create", "update", "delete"];
                            })[key] extends readonly unknown[] ? (O["ac"] extends AccessControl<infer S extends Statements> ? S : {
                                readonly organization: readonly ["update", "delete"];
                                readonly member: readonly ["create", "update", "delete"];
                                readonly invitation: readonly ["create", "cancel"];
                                readonly team: readonly ["create", "update", "delete"];
                            })[key][number] : never)[] | undefined; };
                            permission?: never;
                        }) & {
                            organizationId?: string;
                        };
                    };
                    openapi: {
                        description: string;
                        requestBody: {
                            content: {
                                "application/json": {
                                    schema: {
                                        type: "object";
                                        properties: {
                                            permission: {
                                                type: string;
                                                description: string;
                                                deprecated: boolean;
                                            };
                                            permissions: {
                                                type: string;
                                                description: string;
                                            };
                                        };
                                        required: string[];
                                    };
                                };
                            };
                        };
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                error: {
                                                    type: string;
                                                };
                                                success: {
                                                    type: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            } & {
                use: any[];
            };
            path: "/organization/has-permission";
        };
    };
    schema: {
        team?: {
            modelName: string | undefined;
            fields: {
                name: {
                    type: "string";
                    required: true;
                    fieldName: string | undefined;
                };
                organizationId: {
                    type: "string";
                    required: true;
                    references: {
                        model: string;
                        field: string;
                    };
                    fieldName: string | undefined;
                };
                createdAt: {
                    type: "date";
                    required: true;
                    fieldName: string | undefined;
                };
                updatedAt: {
                    type: "date";
                    required: false;
                    fieldName: string | undefined;
                };
            };
        } | undefined;
        teamMember?: {
            modelName: string | undefined;
            fields: {
                teamId: {
                    type: "string";
                    required: true;
                    fieldName: string | undefined;
                };
                userId: {
                    type: "string";
                    required: true;
                    references: {
                        model: string;
                        field: string;
                    };
                    fieldName: string | undefined;
                };
                createdAt: {
                    type: "date";
                    required: false;
                    fieldName: string | undefined;
                };
            };
        } | undefined;
        session: {
            fields: O["teams"] extends {
                enabled: true;
            } ? {
                activeTeamId: {
                    type: "string";
                    required: false;
                };
                activeOrganizationId: {
                    type: "string";
                    required: false;
                };
            } : {
                activeOrganizationId: {
                    type: "string";
                    required: false;
                };
            };
        };
        organization: {
            modelName: string | undefined;
            fields: {
                name: {
                    type: "string";
                    required: true;
                    sortable: true;
                    fieldName: string | undefined;
                };
                slug: {
                    type: "string";
                    unique: true;
                    sortable: true;
                    fieldName: string | undefined;
                };
                logo: {
                    type: "string";
                    required: false;
                    fieldName: string | undefined;
                };
                createdAt: {
                    type: "date";
                    required: true;
                    fieldName: string | undefined;
                };
                metadata: {
                    type: "string";
                    required: false;
                    fieldName: string | undefined;
                };
            };
        };
        member: {
            modelName: string | undefined;
            fields: {
                organizationId: {
                    type: "string";
                    required: true;
                    references: {
                        model: string;
                        field: string;
                    };
                    fieldName: string | undefined;
                };
                userId: {
                    type: "string";
                    required: true;
                    fieldName: string | undefined;
                    references: {
                        model: string;
                        field: string;
                    };
                };
                role: {
                    type: "string";
                    required: true;
                    sortable: true;
                    defaultValue: string;
                    fieldName: string | undefined;
                };
                createdAt: {
                    type: "date";
                    required: true;
                    fieldName: string | undefined;
                };
            };
        };
        invitation: {
            modelName: string | undefined;
            fields: {
                status: {
                    type: "string";
                    required: true;
                    sortable: true;
                    defaultValue: string;
                    fieldName: string | undefined;
                };
                expiresAt: {
                    type: "date";
                    required: true;
                    fieldName: string | undefined;
                };
                inviterId: {
                    type: "string";
                    references: {
                        model: string;
                        field: string;
                    };
                    fieldName: string | undefined;
                    required: true;
                };
                teamId?: {
                    type: "string";
                    required: false;
                    sortable: true;
                    fieldName: string | undefined;
                } | undefined;
                organizationId: {
                    type: "string";
                    required: true;
                    references: {
                        model: string;
                        field: string;
                    };
                    fieldName: string | undefined;
                };
                email: {
                    type: "string";
                    required: true;
                    sortable: true;
                    fieldName: string | undefined;
                };
                role: {
                    type: "string";
                    required: false;
                    sortable: true;
                    fieldName: string | undefined;
                };
            };
        };
    };
    $Infer: {
        Organization: InferOrganization<O>;
        Invitation: InferInvitation<O>;
        Member: InferMember<O>;
        Team: any;
        TeamMember: any;
        ActiveOrganization: Awaited<ReturnType<ReturnType<typeof getFullOrganization<O>>>>;
    };
    $ERROR_CODES: {
        readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_ORGANIZATION: "You are not allowed to create a new organization";
        readonly YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_ORGANIZATIONS: "You have reached the maximum number of organizations";
        readonly ORGANIZATION_ALREADY_EXISTS: "Organization already exists";
        readonly ORGANIZATION_NOT_FOUND: "Organization not found";
        readonly USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION: "User is not a member of the organization";
        readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_ORGANIZATION: "You are not allowed to update this organization";
        readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_ORGANIZATION: "You are not allowed to delete this organization";
        readonly NO_ACTIVE_ORGANIZATION: "No active organization";
        readonly USER_IS_ALREADY_A_MEMBER_OF_THIS_ORGANIZATION: "User is already a member of this organization";
        readonly MEMBER_NOT_FOUND: "Member not found";
        readonly ROLE_NOT_FOUND: "Role not found";
        readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM: "You are not allowed to create a new team";
        readonly TEAM_ALREADY_EXISTS: "Team already exists";
        readonly TEAM_NOT_FOUND: "Team not found";
        readonly YOU_CANNOT_LEAVE_THE_ORGANIZATION_AS_THE_ONLY_OWNER: "You cannot leave the organization as the only owner";
        readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_MEMBER: "You are not allowed to delete this member";
        readonly YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION: "You are not allowed to invite users to this organization";
        readonly USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION: "User is already invited to this organization";
        readonly INVITATION_NOT_FOUND: "Invitation not found";
        readonly YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION: "You are not the recipient of the invitation";
        readonly YOU_ARE_NOT_ALLOWED_TO_CANCEL_THIS_INVITATION: "You are not allowed to cancel this invitation";
        readonly INVITER_IS_NO_LONGER_A_MEMBER_OF_THE_ORGANIZATION: "Inviter is no longer a member of the organization";
        readonly YOU_ARE_NOT_ALLOWED_TO_INVITE_USER_WITH_THIS_ROLE: "you are not allowed to invite user with this role";
        readonly FAILED_TO_RETRIEVE_INVITATION: "Failed to retrieve invitation";
        readonly YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS: "You have reached the maximum number of teams";
        readonly UNABLE_TO_REMOVE_LAST_TEAM: "Unable to remove last team";
        readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER: "You are not allowed to update this member";
        readonly ORGANIZATION_MEMBERSHIP_LIMIT_REACHED: "Organization membership limit reached";
        readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION: "You are not allowed to create teams in this organization";
        readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION: "You are not allowed to delete teams in this organization";
        readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM: "You are not allowed to update this team";
        readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM: "You are not allowed to delete this team";
        readonly INVITATION_LIMIT_REACHED: "Invitation limit reached";
        readonly TEAM_MEMBER_LIMIT_REACHED: "Team member limit reached";
        readonly USER_IS_NOT_A_MEMBER_OF_THE_TEAM: "User is not a member of the team";
        readonly YOU_CAN_NOT_ACCESS_THE_MEMBERS_OF_THIS_TEAM: "You are not allowed to list the members of this team";
        readonly YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM: "You do not have an active team";
        readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER: "You are not allowed to create a new member";
        readonly YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER: "You are not allowed to remove a team member";
        readonly YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION: "You are not allowed to access this organization as an owner";
        readonly YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION: "You are not a member of this organization";
    };
    options: O;
};

export { defaultRoles, defaultRolesSchema, invitationSchema, invitationStatus, memberSchema, organization, organizationSchema, parseRoles, role, teamMemberSchema, teamSchema };
export type { InferInvitation, InferMember, InferOrganization, InferOrganizationRolesFromOption, InferOrganizationZodRolesFromOption, InferTeam, Invitation, InvitationInput, InvitationStatus, Member, MemberInput, Organization, OrganizationInput, OrganizationOptions, Team, TeamInput, TeamMember, TeamMemberInput };