import 'reflect-metadata';
import { LairRecord } from './record';
export declare enum MetaAttrType {
    NONE = 0,
    FIELD = 1,
    HAS_ONE = 2,
    HAS_MANY = 3,
    SEQUENCE_ITEM = 4
}
export interface FactoryData {
    factory: Factory;
    id: number;
}
export interface Meta {
    [p: string]: MetaAttr | FieldMetaAttr<any> | SequenceMetaAttr<any> | RelationshipMetaAttr;
}
export interface MetaAttr {
    type: MetaAttrType;
    [prop: string]: any;
}
export interface SequenceMetaAttr<T> extends MetaAttr {
    initialValue: T;
    getNextValue: (prevItems: T[]) => T;
    prevValues: T[];
    lastValuesCount: number;
    started: boolean;
}
export interface RelationshipMetaAttr extends MetaAttr {
    factoryName: string;
    invertedAttrName: string;
    reflexive: boolean;
    reflexiveDepth: number;
    createRelated?: number | ((id: string) => number);
}
export interface FieldMetaAttr<T> extends MetaAttr {
    defaultValue?: T;
    allowedValues?: T[];
    preferredType?: string;
    value: T | (() => T);
    getter?: (...args: any[]) => any;
}
export interface RelationshipOptions {
    reflexive?: boolean;
    depth?: number;
    createRelated?: number | ((id: string) => number);
}
export interface SequenceItemOptions {
    lastValuesCount: number;
}
export interface FieldOptions<T> {
    defaultValue?: T;
    preferredType?: string;
    allowedValues?: T[];
}
export interface CreateRecordExtraData {
    relatedTo?: RelatedToData;
    [key: string]: any;
}
export interface RelatedToData {
    currentRecordNumber: number;
    factoryName: string;
    recordsCount: number;
}
export declare const FACTORY_META_KEY: unique symbol;
export declare function field<T>(fieldOptions?: FieldOptions<T>): any;
/**
 * Use `hasOne` for relationship-fields
 * Used for 'one-to-one' and 'one-to-many'
 */
export declare function hasOne(factoryName: string, invertedAttrName: string, options?: RelationshipOptions): any;
/**
 * Use `hasMany` for relationship-fields
 * Used for 'many-to-one' and 'many-to-many'
 */
export declare function hasMany(factoryName: string, invertedAttrName: string, options?: RelationshipOptions): any;
/**
 * Use `sequenceItem` for fields that depend on previously generated values
 */
export declare function sequenceItem<T>(initialValue: T, getNextValue: (prevValues: T[]) => T, options?: SequenceItemOptions): any;
/**
 * Factories are used for data-generation. Each generated data-item is called 'record'.
 * First you need to create a child-class of Factory with filled `attrs`-property.
 * Each `attrs`-field represents one property of the record.
 *
 * Value for each field may be one of the 3 types - static, dynamic and relationship:
 *  - Static field has value that is the same for all generated records for current factory
 *  - Dynamic field is recalculated for every generated record
 *  - Relationship field is used to show that value is a record of the another factory.
 *    Relationship may be "has_one" (single record) and "has_many" (array of records)
 *  - Sequence item which value is based on previously generated values (for older records)
 */
export declare class Factory {
    static factoryName: string;
    static internalMeta: Meta;
    static resetMeta(): void;
    afterCreateRelationshipsDepth: number;
    afterCreateIgnoreRelated: string[];
    allowCustomIds: boolean;
    protected cache: Map<any, any>;
    protected currentRecordId: any;
    protected _id: any;
    get id(): any;
    set id(v: any);
    get meta(): Meta;
    /**
     * Forget about this. It's only for Lair
     */
    createRecord(id: number, extraData?: CreateRecordExtraData): LairRecord;
    afterCreate(record: LairRecord, extraData: CreateRecordExtraData): LairRecord;
    getFactoryName(): string;
    /**
     * Return object with default values for attributes
     * Only attributes with type `FIELD` and provided `defaultValue` are affected
     */
    getDefaults(): Record<string, unknown>;
    constructor();
    protected softInitMeta(): void;
    protected mergeMetaWithParent(): void;
    protected getNewRecord(id: number, extraData?: CreateRecordExtraData): LairRecord;
}