import * as pocketbase from 'pocketbase';
import pocketbase__default, { RecordSubscription, SendOptions, UnsubscribeFunc, ListResult, RecordService, RecordAuthResponse, OAuth2AuthConfig, RecordOptions, CommonOptions, SubBatchService, BatchRequestResult } from 'pocketbase';

type Prettify<T> = T extends infer o ? {
    [K in keyof o]: o[K];
} : never;
type MaybeArray<T> = T | T[];
type MaybeMakeArray<T, Out> = T extends any[] ? Out[] : Out;
type ArrayInnerType<T> = T extends Array<infer V> ? V : T;
type Values<T> = T[keyof T];
type Overide<A, B> = Prettify<Omit<A, keyof B> & B>;
type RemoveIndex<T> = {
    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K];
};
type LooseAutocomplete<T> = T | (string & {});
type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
type BaseRecord = Record<string, any>;
type BaseSystemFields = {
    id: string;
    created: string;
    updated: string;
};
type GenericCollection = {
    type: string;
    collectionId: string;
    collectionName: string;
    response: BaseRecord;
    create?: BaseRecord;
    update?: BaseRecord;
    relations: Record<string, GenericCollection | GenericCollection[]>;
};
type GenericSchema = {
    [K: string]: GenericCollection;
};
type TypedRecord<Data extends BaseRecord, Expand extends GenericExpand = {}> = Data & {
    expand: Expand;
};
interface SystemFields {
    id: string;
    created: string;
    update: string;
}
type BaseCollectionRecords = Record<string, BaseRecord>;
type Fields<T extends GenericCollection> = keyof T['response'];
type Columns<T extends GenericCollection> = T['response'];
type Expands<T extends GenericCollection> = {
    [K in keyof T['relations']]?: T['relations'][K] extends GenericCollection[] ? TypedRecord<T['relations'][K][number], Expands<T['relations'][K][number]>>[] : T['relations'][K] extends GenericCollection ? TypedRecord<T['relations'][K], Expands<T['relations'][K]>> : never;
};
type GenericExpand = Record<string, TypedRecord<any> | TypedRecord<any>[]>;
type JoinPath<Parts extends string[]> = Parts extends [
    infer A extends string,
    ...infer Rest extends string[]
] ? Rest['length'] extends 0 ? A : `${A}.${JoinPath<Rest>}` : never;
type _RecordWithExpandToDotPath<T extends GenericCollection, Path extends string[] = []> = {
    [K in keyof T['response'] as JoinPath<[
        ...Path,
        K & string
    ]>]: T['response'][K];
} & (Path['length'] extends 4 ? {} : UnionToIntersection<Values<{
    [K in keyof T['relations']]: _RecordWithExpandToDotPath<ArrayInnerType<T['relations'][K]>, [
        ...Path,
        K & string
    ]>;
}>>);
type RecordWithExpandToDotPath<T extends GenericCollection> = Prettify<_RecordWithExpandToDotPath<T>>;
type ReservedRecordNames = 'collectionId' | 'collectionName';

type Select<Collection extends GenericCollection> = {
    [K in keyof Collection['response']]?: boolean;
};
type SelectWithExpand<Collection extends GenericCollection> = Select<Collection> & {
    expand?: {
        [K in keyof Collection['relations']]?: SelectWithExpand<ArrayInnerType<Collection['relations'][K]>> | boolean;
    };
};
type ResolveSelect<TCollection extends GenericCollection, TSelect extends Select<TCollection> | undefined> = Extract<keyof TSelect, keyof TCollection['response']> extends never ? TCollection['response'] : {
    [K in keyof TSelect & keyof TCollection['response'] as TSelect[K] extends true ? K : never]: TCollection['response'][K];
};
type ResolveSelectWithExpand<TCollection extends GenericCollection, TSelect extends Select<TCollection> | undefined> = Prettify<ResolveSelect<TCollection, TSelect> & ('expand' extends keyof TSelect ? {
    expand?: {
        [Relation in keyof TSelect['expand'] & keyof TCollection['relations'] as TSelect['expand'][Relation] extends false ? never : Relation]?: TSelect['expand'][Relation] extends true ? MaybeMakeArray<TCollection['relations'][Relation], ArrayInnerType<TCollection['relations'][Relation]>['response']> : TSelect['expand'][Relation] extends object ? MaybeMakeArray<TCollection['relations'][Relation], ResolveSelectWithExpand<ArrayInnerType<TCollection['relations'][Relation]>, TSelect['expand'][Relation]>> : never;
    };
} : {})>;

type ActualFilter<T extends any, K extends keyof T = keyof T> = [
    K,
    FilterOperand,
    T[K]
];
type FilterOperand = '=' | '!=' | '>' | '>=' | '<' | '<=' | '~' | '!~' | '?=' | '?!=' | '?>' | '?>=' | '?<' | '?<=' | '?~' | '?!~';
type FilterParam<T extends BaseRecord> = {
    __record__?: T;
} & string;
type Filter<T extends BaseRecord> = ActualFilter<T> | FilterParam<T> | false | null | undefined;
declare function and<T extends BaseRecord>(...filters: Filter<T>[]): FilterParam<T>;
declare function or<T extends BaseRecord>(...filters: Filter<T>[]): FilterParam<T>;
declare function eq<T extends BaseRecord, Key extends keyof T>(column: Key, value: T[Key]): FilterParam<T>;
declare function neq<T extends BaseRecord, Key extends keyof T>(column: Key, value: T[Key]): FilterParam<T>;
declare function gt<T extends BaseRecord, Key extends keyof T>(column: Key, value: T[Key]): FilterParam<T>;
declare function gte<T extends BaseRecord, Key extends keyof T>(column: Key, value: T[Key]): FilterParam<T>;
declare function lt<T extends BaseRecord, Key extends keyof T>(column: Key, value: T[Key]): FilterParam<T>;
declare function lte<T extends BaseRecord, Key extends keyof T>(column: Key, value: T[Key]): FilterParam<T>;
declare function like<T extends BaseRecord, Key extends keyof T>(column: Key, value: T[Key]): FilterParam<T>;
declare function nlike<T extends BaseRecord, Key extends keyof T>(column: Key, value: T[Key]): FilterParam<T>;

type Sort<T extends BaseRecord> = `${'+' | '-'}${keyof T & string}` | false | null | undefined;

declare const FORWARD_METHODS: readonly ["unsubscribe", "listAuthMethods", "requestPasswordReset", "confirmPasswordReset", "requestVerification", "confirmVerification", "requestEmailChange", "confirmEmailChange", "listExternalAuths", "unlinkExternalAuth", "requestOTP"];
interface ViewCollectionService<Collection extends GenericCollection, ExpandedRecord extends BaseRecord = RecordWithExpandToDotPath<Collection>> {
    collectionName: Collection['collectionName'];
    client: pocketbase__default;
    subscribe<TSelect extends SelectWithExpand<Collection> | undefined>(topic: string, callback: (data: RecordSubscription<ResolveSelectWithExpand<Collection, TSelect>>) => void, options?: {
        select?: TSelect;
    } & SendOptions): Promise<UnsubscribeFunc>;
    getFullList<TSelect extends SelectWithExpand<Collection> | undefined>(options?: {
        select?: TSelect;
        page?: number;
        perPage?: number;
        sort?: MaybeArray<Sort<ExpandedRecord>>;
        filter?: Filter<ExpandedRecord>;
    } & SendOptions): Promise<ResolveSelectWithExpand<Collection, TSelect>[]>;
    getList<TSelect extends SelectWithExpand<Collection> = {}>(page?: number, perPage?: number, options?: {
        select?: TSelect;
        sort?: MaybeArray<Sort<ExpandedRecord>>;
        filter?: Filter<ExpandedRecord>;
    } & SendOptions): Promise<ListResult<ResolveSelectWithExpand<Collection, TSelect>>>;
    getFirstListItem<TSelect extends SelectWithExpand<Collection> = {}>(filter: Filter<ExpandedRecord>, options?: {
        select?: TSelect;
        sort?: MaybeArray<Sort<ExpandedRecord>>;
    } & SendOptions): Promise<ResolveSelectWithExpand<Collection, TSelect>>;
    getOne<TSelect extends SelectWithExpand<Collection> = {}>(id: string, options?: {
        select?: TSelect;
    } & SendOptions): Promise<ResolveSelectWithExpand<Collection, TSelect>>;
    createFilter(filter: Filter<ExpandedRecord>): Filter<ExpandedRecord>;
    createSort(...sort: Sort<ExpandedRecord>[]): Sort<ExpandedRecord>;
    createSelect<T extends SelectWithExpand<Collection>>(select: T): T;
}
interface BaseCollectionService<Collection extends GenericCollection> extends ViewCollectionService<Collection> {
    create<TSelect extends SelectWithExpand<Collection> = {}>(bodyParams: Collection['create'], options?: {
        select?: TSelect;
    } & SendOptions): Promise<ResolveSelectWithExpand<Collection, TSelect>>;
    update<TSelect extends SelectWithExpand<Collection> = {}>(id: string, bodyParams: Collection['update'], options?: {
        select?: TSelect;
    } & SendOptions): Promise<ResolveSelectWithExpand<Collection, TSelect>>;
    delete(id: string): Promise<boolean>;
}
interface AuthCollectionService<Collection extends GenericCollection> extends BaseCollectionService<Collection>, Pick<RecordService, (typeof FORWARD_METHODS)[number]> {
    /**
     * Authenticates a user with a password.
     *
     * @param usernameOrEmail the username or email of the user
     * @param password the password of the user
     * @param options optional settings for the request
     *
     * @returns a promise that resolves to the record's authentication response
     */
    authWithPassword<TSelect extends SelectWithExpand<Collection> = {}>(usernameOrEmail: string, password: string, options?: {
        select?: TSelect;
    } & SendOptions): Promise<RecordAuthResponse<ResolveSelectWithExpand<Collection, TSelect>>>;
    /**
     * Authenticates a user via OAuth2 authorization code flow.
     *
     * @param provider the OAuth2 provider name
     * @param code the authorization code
     * @param codeVerifier the code verifier
     * @param redirectUrl the redirect URL
     * @param createData optional data to create a new record with (if the user doesn't exist)
     * @param options optional settings for the request
     *
     * @returns a promise that resolves to the record's authentication response
     */
    authWithOAuth2Code<TSelect extends SelectWithExpand<Collection> = {}>(provider: string, code: string, codeVerifier: string, redirectUrl: string, createData?: {
        [key: string]: any;
    }, options?: {
        select?: TSelect;
    } & SendOptions): Promise<RecordAuthResponse<ResolveSelectWithExpand<Collection, TSelect>>>;
    /**
     * Authenticates a user using the OAuth2 flow.
     *
     * If the user is already authenticated, the request will be rejected.
     *
     * @param options settings for the request.
     * @param options.createData optional data to use when creating a new user.
     * @param options.select optional select clause for the response.
     * @param options... additional options to pass to the underlying method.
     *
     * @returns a promise that resolves with the authentication response
     */
    authWithOAuth2(options: Omit<OAuth2AuthConfig, 'createData'> & {
        createData?: Collection['create'];
    } & SendOptions): Promise<RecordAuthResponse<Collection['response']>>;
    /**
     * Authenticates a user using the refresh token.
     *
     * @param options Optional settings for the request.
     * @param options.select Optional select clause for the response.
     * @param options.select Optional select clause for the response.
     * @returns A promise that resolves to the authenticated user data.
     */
    authRefresh<TSelect extends SelectWithExpand<Collection> = {}>(options?: {
        select?: TSelect;
    } & SendOptions): Promise<RecordAuthResponse<ResolveSelectWithExpand<Collection, TSelect>>>;
    /**
     * Authenticates a user using the provided OTP id and password.
     *
     * Only works with `auth` collections.
     *
     * @param otpId the OTP id to use for the authentication
     * @param password the password to use for the authentication
     * @param options additional options to pass to the underlying method
     *
     * @returns a promise that resolves with the authentication response
     */
    authWithOTP<TSelect extends SelectWithExpand<Collection> = {}>(otpId: string, password: string, options?: {
        select?: TSelect;
    } & SendOptions): Promise<RecordAuthResponse<ResolveSelectWithExpand<Collection, TSelect>>>;
}

type TypedRecordServiceSchema = Omit<AuthCollectionService<GenericCollection>, 'unsubscribe' | 'listAuthMethods' | 'requestPasswordReset' | 'confirmPasswordReset' | 'requestVerification' | 'confirmVerification' | 'requestEmailChange' | 'confirmEmailChange' | 'listExternalAuths' | 'unlinkExternalAuth' | 'requestOTP'>;
declare class TypedRecordService<Schema extends GenericSchema> implements TypedRecordServiceSchema {
    readonly service: RecordService<any>;
    constructor(service: RecordService<any>);
    get client(): pocketbase.default;
    get collectionName(): string;
    private prepareOptions;
    createFilter(filter: Filter<Record<string, any>>): string | null;
    createSort(...sorters: any[]): any;
    createSelect(select: any): any;
    subscribe(topic: string, callback: (data: RecordSubscription<any>) => void, options?: SendOptions): Promise<UnsubscribeFunc>;
    getFullList(options?: SendOptions): Promise<any[]>;
    getList(page?: number, perPage?: number, options?: SendOptions): Promise<pocketbase.ListResult<any>>;
    getFirstListItem(filter: string, options?: SendOptions): Promise<any>;
    getOne(id: string, options?: {
        select?: any;
    } & SendOptions): Promise<any>;
    create(bodyParams?: {
        [key: string]: any;
    } | FormData, options?: {
        select?: any;
    } & SendOptions): Promise<any>;
    update(id: string, bodyParams?: FormData | {
        [key: string]: any;
    }, options?: {
        select?: any;
    } & SendOptions): Promise<any>;
    delete(id: string, options?: SendOptions): Promise<boolean>;
    authWithPassword(usernameOrEmail: string, password: string, options?: RecordOptions | undefined): Promise<RecordAuthResponse<any>>;
    authWithOAuth2Code(provider: string, code: string, codeVerifier: string, redirectUrl: string, createData?: {
        [key: string]: any;
    } | undefined, options?: RecordOptions | undefined): Promise<RecordAuthResponse<any>>;
    authWithOAuth2(options: OAuth2AuthConfig): Promise<RecordAuthResponse>;
    authRefresh(options?: RecordOptions | undefined): Promise<RecordAuthResponse<any>>;
    authWithOTP(otpId: string, password: string, options?: CommonOptions): Promise<RecordAuthResponse<any>>;
}

declare class TypedBatch<Schema extends GenericSchema> {
    private pb;
    private batch;
    /**
     * Creates a new instance of {@link TypedBatch}.
     *
     * @param pb The {@link TypedPocketBase} instance to use.
     */
    constructor(pb: TypedPocketBase<Schema>);
    /**
     * Returns a typed {@link TypedBatchCollection} instance for the given collection.
     *
     * @template CollectionName The name of the collection.
     * @param name The name of the collection.
     * @returns A typed {@link TypedBatchCollection} instance for the given collection.
     */
    from<CollectionName extends keyof Schema>(name: CollectionName): TypedBatchCollection<Schema[CollectionName]>;
    /**
     * Sends all the collected batch operations to the server.
     *
     * @param options optional settings for the request
     *
     * @returns a promise that resolves to an array of {@link BatchRequestResult}
     * with the results of all batch operations, in the same order as they were
     * added to the batch
     */
    send(options?: SendOptions): Promise<Array<BatchRequestResult>>;
}
declare class TypedBatchCollection<Collection extends GenericCollection> {
    private batchService;
    constructor(batchService: SubBatchService);
    /**
     * Creates a new record in the batch service.
     * @param bodyParams The create data.
     * @param options Optional options to pass to the underlying `create` method.
     * @see https://pocketbase.io/docs/api-records/#create-record
     */
    create(bodyParams: Collection['create'], options?: RecordOptions): void;
    /**
     * Creates multiple records in the batch service.
     * @param bodyParams The list of create data to create the records with.
     * @param options Optional options to pass to the underlying `create` method.
     * @see https://pocketbase.io/docs/api-records/#create-record
     */
    createMany(bodyParams: Collection['create'][], options?: RecordOptions): void;
    /**
     * Queues an update operation for the given record.
     *
     * @param id The id of the record to update.
     * @param bodyParams The body parameters to update the record with.
     * @param options Additional options to pass to the underlying `update` method.
     */
    update(id: string, bodyParams: Collection['update'], options?: RecordOptions): void;
    /**
     * Queues multiple update operations for the same record.
     *
     * @param id The id of the record to update.
     * @param bodyParams The array of body parameters to update the record with.
     * @param options Additional options to pass to the underlying `update` method.
     */
    updateMany(id: string, bodyParams: Collection['update'][], options?: RecordOptions): void;
    /**
     * Queues a delete operation for the given record.
     *
     * @param bodyParams The body parameters with the `id` of the record to delete.
     * @param options Additional options to pass to the underlying `delete` method.
     */
    delete(bodyParams: Partial<Collection['update']> & {
        id: string;
    }, options?: SendOptions): void;
    /**
     * Adds multiple delete requests to the batch for the provided `bodyParams`.
     * @param bodyParams The list of body parameters with the `id` property to delete.
     * @param options Optional settings for the request.
     * @returns a promise that resolves when the request is submitted
     */
    deleteMany(bodyParams: Partial<Collection['update']> & {
        id: string;
    }[], options?: SendOptions): void;
    /**
     * Adds a delete request to the batch for the provided `id`.
     *
     * @param id the id of the record to delete
     * @param options optional settings for the request
     */
    deleteById(id: string, options?: SendOptions): void;
    /**
     * Adds multiple delete requests to the batch for the provided `ids`.
     *
     * @param ids the ids of the records to delete
     * @param options optional settings for the request
     */
    deleteManyById(ids: string[], options?: SendOptions): void;
    /**

     * Adds an upsert request to the batch for the provided `bodyParams`.
     *
     * @param bodyParams the data to upsert
     * @param options optional settings for the request
     * @returns a promise that resolves when the request is submitted
     */
    upsert(bodyParams: Collection['update'], options?: RecordOptions): void;
}

declare class TypedPocketBase<Schema extends GenericSchema> extends pocketbase__default {
    /**
     * Creates a typed {@link TypedRecordService} instance for the given collection.
     *
     * @template CollectionName The name of the collection.
     * @template Collection The collection type. Defaults to `Schema[CollectionName]`.
     * @param name The name of the collection.
     * @returns A typed {@link ViewCollectionService} instance if the collection is a view,
     * a typed {@link BaseCollectionService} instance if the collection is a base collection,
     * or a typed {@link AuthCollectionService} instance if the collection is an auth collection.
     */
    from<CollectionName extends keyof Schema, Collection extends GenericCollection = Schema[CollectionName]>(name: CollectionName): Collection['type'] extends 'view' ? ViewCollectionService<Collection> : Collection['type'] extends 'base' ? BaseCollectionService<Collection> : AuthCollectionService<Collection>;
    /**
     * Returns a new instance of {@link TypedBatch} to be used for batching record operations.
     *
     * @returns A new instance of {@link TypedBatch}.
     */
    fromBatch(): TypedBatch<Schema>;
    /**
     * Temporarily impersonates the provided record id as if it was the real authenticated user.
     *
     * Only works for `auth` collections.
     *
     * @param collectionName - The collection name of the collection.
     * @param recordId - The id of the record to impersonate.
     * @param duration - The amount of milliseconds to impersonate for.
     * @param options - Additional options to pass to the underlying `impersonate` method.
     *
     * @returns A promise that resolves to the impersonated client instance if the collection is an `auth` collection, or `never` otherwise.
     */
    impersonate<CollectionName extends keyof Schema, Collection extends GenericCollection = Schema[CollectionName]>(collectionName: CollectionName, recordId: string, duration: number, options?: CommonOptions): Collection['type'] extends 'auth' ? Promise<Omit<TypedPocketBase<Schema>, 'impersonate'>> : Promise<never>;
}

export { type ActualFilter, type ArrayInnerType, type AuthCollectionService, type BaseCollectionRecords, type BaseCollectionService, type BaseRecord, type BaseSystemFields, type Columns, type Expands, type Fields, type Filter, type FilterOperand, type FilterParam, type GenericCollection, type GenericExpand, type GenericSchema, type LooseAutocomplete, type MaybeArray, type MaybeMakeArray, type Overide, type Prettify, type RecordWithExpandToDotPath, type RemoveIndex, type ReservedRecordNames, type ResolveSelect, type ResolveSelectWithExpand, type Select, type SelectWithExpand, type Sort, type SystemFields, TypedPocketBase, type TypedRecord, TypedRecordService, type UnionToIntersection, type Values, type ViewCollectionService, and, eq, gt, gte, like, lt, lte, neq, nlike, or };