import { AnyZodObject } from 'zod';
import { Query, EmptyObject, CreateData } from 'pqb';
import { InstanceToZod } from 'porm-schema-to-zod';

declare type FactoryOptions = {
    sequence?: number;
    sequenceDistance?: number;
    maxTextLength?: number;
};
declare type metaKey = typeof metaKey;
declare const metaKey: unique symbol;
declare type Result<T extends TestFactory, Data, Omitted = Omit<Data, keyof T[metaKey]['omit']>> = EmptyObject extends T[metaKey]['pick'] ? Omitted : Pick<Omitted, {
    [K in keyof Omitted]: K extends keyof T[metaKey]['pick'] ? K : never;
}[keyof Omitted]>;
declare type BuildArg<T extends TestFactory> = {
    [K in keyof T[metaKey]['type']]?: T[metaKey]['type'][K] | ((sequence: number) => T[metaKey]['type'][K]);
} & Record<string, unknown>;
declare type BuildResult<T extends TestFactory, Data extends BuildArg<T>> = Result<T, BuildArg<T> extends Data ? T[metaKey]['type'] : T[metaKey]['type'] & {
    [K in keyof Data]: Data[K] extends () => void ? ReturnType<Data[K]> : Data[K];
}>;
declare type CreateArg<T extends TestFactory> = CreateData<Omit<T['model'], 'inputType'> & {
    inputType: {
        [K in keyof T['model']['type']]?: T['model']['type'][K] | ((sequence: number) => T['model']['type'][K]);
    };
}>;
declare type CreateResult<T extends TestFactory> = Result<T, T['model']['type']>;
declare class TestFactory<Q extends Query = Query, Schema extends AnyZodObject = AnyZodObject, Type extends EmptyObject = EmptyObject> {
    model: Q;
    schema: Schema;
    private readonly data;
    sequence: number;
    private readonly omitValues;
    private readonly pickValues;
    [metaKey]: {
        type: Type;
        omit: EmptyObject;
        pick: EmptyObject;
    };
    constructor(model: Q, schema: Schema, data?: Record<string, unknown>, options?: FactoryOptions);
    set<T extends this, Meta extends {
        type: EmptyObject;
    }, Data extends {
        [K in keyof Meta['type']]?: Meta['type'][K] | (() => Meta['type'][K]);
    } & Record<string, unknown>>(this: T & {
        [metaKey]: Meta;
    }, data: Data): T & {
        [metaKey]: Meta & {
            type: Data;
        };
    };
    omit<T extends this, Keys extends {
        [K in keyof T[metaKey]['type']]?: true;
    }>(this: T, keys: Keys): T & {
        [metaKey]: T[metaKey] & {
            omit: Keys;
        };
    };
    pick<T extends this, Keys extends {
        [K in keyof T[metaKey]['type']]?: true;
    }>(this: T, keys: Keys): T & {
        [metaKey]: T[metaKey] & {
            pick: Keys;
        };
    };
    build<T extends this, Data extends BuildArg<T>>(this: T, data?: Data): BuildResult<T, Data>;
    buildList<T extends this, Data extends BuildArg<T>>(this: T, qty: number, data?: Data): BuildResult<T, Data>[];
    create<T extends this, Data extends CreateArg<T>>(this: T, data?: Data): Promise<CreateResult<T>>;
    createList<T extends this, Data extends CreateArg<T>>(this: T, qty: number, data?: Data): Promise<CreateResult<T>[]>;
    extend<T extends this>(this: T): new () => TestFactory<Q, Schema, Type>;
}
declare const createFactory: <T extends Query>(model: T, options?: FactoryOptions) => TestFactory<T, InstanceToZod<T>, T["type"]>;

export { TestFactory, createFactory };