better-auth-invite/dist/index.d.ts

**UNDER DEVELOPMENT — ALPHA**

import type { UserWithRole } from "better-auth/plugins";
import { z } from "zod";
export interface InviteOptions {
    inviteDurationSeconds: number;
    roleForSignupWithoutInvite: string;
    roleForSignupWithInvite: string;
    canCreateInvite?: (user: UserWithRole) => boolean;
    generateCode?: () => string;
    getDate?: () => Date;
}
export declare const invite: (options: InviteOptions) => {
    id: "invite";
    endpoints: {
        create: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    _: true;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: import("better-auth").Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {
                    code: string;
                };
            } : {
                code: string;
            }>;
            options: {
                body: z.ZodObject<{
                    _: z.ZodLiteral<true>;
                }, "strip", z.ZodTypeAny, {
                    _: true;
                }, {
                    _: true;
                }>;
                method: "POST";
                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            name: string;
                            email: string;
                            emailVerified: boolean;
                            createdAt: Date;
                            updatedAt: Date;
                            image?: string | null | undefined;
                        };
                    };
                }>)[];
            } & {
                use: any[];
            };
            path: "/invite/create";
        };
        activate: {
            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
                body: {
                    code: string;
                };
            } & {
                method?: "POST" | undefined;
            } & {
                query?: Record<string, any> | undefined;
            } & {
                params?: Record<string, any>;
            } & {
                request?: Request;
            } & {
                headers?: HeadersInit;
            } & {
                asResponse?: boolean;
                returnHeaders?: boolean;
                use?: import("better-auth").Middleware[];
                path?: string;
            } & {
                asResponse?: AsResponse | undefined;
                returnHeaders?: ReturnHeaders | undefined;
            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
                headers: Headers;
                response: {};
            } : {}>;
            options: {
                method: "POST";
                body: z.ZodObject<{
                    code: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    code: string;
                }, {
                    code: string;
                }>;
            } & {
                use: any[];
            };
            path: "/invite/activate";
        };
    };
    hooks: {
        after: {
            matcher: (context: import("better-auth").HookEndpointContext) => boolean;
            handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
        }[];
    };
    $ERROR_CODES: {
        readonly USER_NOT_LOGGED_IN: "User must be logged in to create an invite";
        readonly INSUFFICIENT_PERMISSIONS: "User does not have sufficient permissions to create invite";
        readonly NO_SUCH_USER: "No such user";
        readonly NO_USES_LEFT_FOR_INVITE_CODE: "No uses left for invite code";
        readonly INVALID_OR_EXPIRED_INVITE: "Invalid or expired invite code";
    };
    schema: {
        invite: {
            fields: {
                code: {
                    type: "string";
                    unique: true;
                };
                createdAt: {
                    type: "date";
                    defaultValue: () => Date;
                };
                expiresAt: {
                    type: "date";
                    required: true;
                };
                maxUses: {
                    type: "number";
                    required: true;
                };
                createdByUserId: {
                    type: "string";
                    references: {
                        model: string;
                        field: string;
                        onDelete: "set null";
                    };
                };
            };
        };
        invite_use: {
            fields: {
                inviteId: {
                    type: "string";
                    required: true;
                    references: {
                        model: string;
                        field: string;
                        onDelete: "set null";
                    };
                };
                usedAt: {
                    type: "date";
                    required: true;
                };
                usedByUserId: {
                    type: "string";
                    required: false;
                    references: {
                        model: string;
                        field: string;
                        onDelete: "set null";
                    };
                };
            };
        };
    };
};
export * from "./client.js";