import { Passkey } from '@better-auth/passkey';
import { BetterFetchError } from '@better-fetch/fetch';
import { Account, User } from 'better-auth';
import { Organization, Member } from 'better-auth/plugins/organization';
import { createAuthClient } from 'better-auth/react';

type Refetch = () => Promise<unknown> | unknown;

type AnyAuthClient = Omit<ReturnType<typeof createAuthClient>, "signUp" | "getSession">;

type ApiKey = {
    id: string;
    name?: string | null;
    start?: string | null;
    expiresAt?: Date | null;
    createdAt: Date;
    updatedAt: Date;
    metadata?: Record<string, unknown> | null;
};

declare const authClient: any;
type AuthClient = typeof authClient;
type Session = AuthClient["$Infer"]["Session"]["session"];

type Invitation = {
    id: string;
    organizationId: string;
    email: string;
    role: string;
    status: string;
    inviterId: string;
    expiresAt: Date;
    teamId?: string | undefined;
};

type AnyAuthSession = AnyAuthClient["$Infer"]["Session"];
type AuthHook<T> = {
    isPending: boolean;
    isRefetching: boolean;
    data?: T | null;
    error?: BetterFetchError | null;
    refetch?: Refetch;
};
type AuthHooks = {
    useSession: () => ReturnType<AnyAuthClient["useSession"]>;
    useListAccounts: () => AuthHook<Account[]>;
    useAccountInfo: (params: Parameters<AuthClient["accountInfo"]>[0]) => AuthHook<{
        user: User;
    }>;
    useListDeviceSessions: () => AuthHook<AnyAuthClient["$Infer"]["Session"][]>;
    useListSessions: () => AuthHook<AnyAuthSession["session"][]>;
    useListPasskeys: () => AuthHook<Passkey[]>;
    useListApiKeys: () => AuthHook<{
        apiKeys: ApiKey[];
    }>;
    useActiveOrganization: () => Partial<ReturnType<AuthClient["useActiveOrganization"]>>;
    useListOrganizations: () => Partial<AuthHook<Organization[]>>;
    useHasPermission: (params: Parameters<AuthClient["organization"]["hasPermission"]>[0]) => AuthHook<{
        error: null;
        success: boolean;
    }>;
    useInvitation: (params: Parameters<AuthClient["organization"]["getInvitation"]>[0]) => AuthHook<Invitation & {
        organizationName: string;
        organizationSlug: string;
        organizationLogo?: string;
    }>;
    useListInvitations: (params: Parameters<AuthClient["organization"]["listInvitations"]>[0]) => AuthHook<Invitation[]>;
    useListUserInvitations: () => AuthHook<Invitation[]>;
    useListMembers: (params: Parameters<AuthClient["organization"]["listMembers"]>[0]) => AuthHook<{
        members: (Member & {
            user?: Partial<User> | null;
        })[];
        total: number;
    }>;
    useListTeams: (params?: {
        organizationId?: string;
    }) => AuthHook<Team[]>;
    useListTeamMembers: (params: {
        teamId?: string;
    }) => AuthHook<TeamMember[]>;
    useListUserTeams: () => AuthHook<Team[]>;
    useIsRestoring?: () => boolean;
};
type Team = {
    id: string;
    name: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
};
type TeamMember = {
    id: string;
    teamId: string;
    userId: string;
    createdAt: Date;
    user?: Partial<User> | null;
};

export type { AnyAuthClient as A, Refetch as R, Session as S, Team as T, AuthHooks as a, TeamMember as b, AuthClient as c };