/**
 * Base factory for creating mock data with type safety
 */
import type { MockDataFactory } from '../types';
/**
 * Base factory class for creating mock data
 */
export declare abstract class BaseFactory<T> {
    /**
     * Create a single instance with optional overrides
     */
    abstract create(overrides?: Partial<T>): T;
    /**
     * Create multiple instances
     */
    createMany(count: number, overrides?: Partial<T>): T[];
    /**
     * Create instances with different overrides for each
     */
    createManyWithOverrides(overridesArray: Array<Partial<T>>): T[];
    /**
     * Create a sequence of instances with incremental values
     */
    createSequence(count: number, sequenceFn: (index: number) => Partial<T>): T[];
    /**
     * Create instances with random variations
     */
    createVariations(count: number, variationFn: () => Partial<T>): T[];
}
/**
 * Simple factory function creator
 */
export declare function createFactory<T>(factoryFn: (overrides?: Partial<T>) => T): MockDataFactory<T>;
/**
 * Factory builder for creating complex factories
 */
export declare class FactoryBuilder<T> {
    private baseFn;
    private traits;
    private sequences;
    private afterBuildHooks;
    constructor(baseFn: (overrides?: Partial<T>) => T);
    /**
     * Add a trait (named set of attributes)
     */
    trait(name: string, attributes: Partial<T>): this;
    /**
     * Add a sequence for generating incremental values
     */
    sequence<K extends keyof T>(key: K, sequenceFn: (n: number) => T[K]): this;
    /**
     * Add after-build hook
     */
    afterBuild(fn: (instance: T) => T): this;
    /**
     * Build the factory
     */
    build(): FactoryInstance<T>;
}
/**
 * Factory instance with trait and sequence support
 */
export declare class FactoryInstance<T> {
    private baseFn;
    private traits;
    private sequences;
    private afterBuildHooks;
    constructor(baseFn: (overrides?: Partial<T>) => T, traits: Map<string, Partial<T>>, sequences: Map<string, () => any>, afterBuildHooks: Array<(instance: T) => T>);
    /**
     * Create instance with optional traits and overrides
     */
    create(overrides?: Partial<T>, traitNames?: string[]): T;
    /**
     * Create with specific traits
     */
    withTraits(...traitNames: string[]): {
        create: (overrides?: Partial<T>) => T;
        createMany: (count: number, overrides?: Partial<T>) => T[];
    };
    /**
     * Create multiple instances
     */
    createMany(count: number, overrides?: Partial<T>, traitNames?: string[]): T[];
}
/**
 * Create a factory builder
 */
export declare function defineFactory<T>(baseFn: (overrides?: Partial<T>) => T): FactoryBuilder<T>;
/**
 * Utility for creating factories with default values
 */
export declare function createFactoryWithDefaults<T extends object>(defaults: T, customizations?: Partial<Record<keyof T, () => T[keyof T]>>): MockDataFactory<T>;
//# sourceMappingURL=base-factory.d.ts.map