/**
 * TestDataFactory - Generate test fixtures and synthetic data
 *
 * Provides methods to generate test fixtures from use case examples,
 * edge case data (boundary values, null, invalid), and synthetic data
 * for comprehensive test coverage.
 *
 * @module src/testing/fixtures/test-data-factory
 */
export interface DataSchema {
    name: string;
    fields: FieldSchema[];
}
export interface FieldSchema {
    name: string;
    type: FieldType;
    constraints?: FieldConstraints;
    nullable?: boolean;
    defaultValue?: any;
}
export type FieldType = 'string' | 'number' | 'integer' | 'boolean' | 'date' | 'datetime' | 'email' | 'url' | 'uuid' | 'enum' | 'array' | 'object';
export interface FieldConstraints {
    minLength?: number;
    maxLength?: number;
    min?: number;
    max?: number;
    pattern?: string;
    enumValues?: string[];
    format?: string;
}
export interface GeneratedFixture {
    valid: Record<string, any>;
    invalid: Record<string, any>[];
    boundary: Record<string, any>[];
    nullCases: Record<string, any>[];
}
export interface FixtureOptions {
    includeInvalid?: boolean;
    includeBoundary?: boolean;
    includeNullCases?: boolean;
    seed?: number;
    count?: number;
}
export declare class TestDataFactory {
    private seed;
    private rng;
    constructor(seed?: number);
    /**
     * Generate fixtures from a data schema
     *
     * @param schema - Data schema definition
     * @param options - Generation options
     * @returns Generated fixtures
     */
    generateFromSchema(schema: DataSchema, options?: FixtureOptions): GeneratedFixture;
    /**
     * Generate a valid record based on schema
     *
     * @param schema - Data schema
     * @returns Valid record
     */
    generateValidRecord(schema: DataSchema): Record<string, any>;
    /**
     * Generate multiple valid records
     *
     * @param schema - Data schema
     * @param count - Number of records to generate
     * @returns Array of valid records
     */
    generateValidRecords(schema: DataSchema, count: number): Record<string, any>[];
    /**
     * Generate invalid records (one invalid field per record)
     *
     * @param schema - Data schema
     * @param count - Maximum number of invalid records
     * @returns Array of invalid records
     */
    generateInvalidRecords(schema: DataSchema, count: number): Record<string, any>[];
    /**
     * Generate boundary value records
     *
     * @param schema - Data schema
     * @returns Array of boundary records
     */
    generateBoundaryRecords(schema: DataSchema): Record<string, any>[];
    /**
     * Generate null case records (null for each nullable field)
     *
     * @param schema - Data schema
     * @returns Array of null case records
     */
    generateNullCaseRecords(schema: DataSchema): Record<string, any>[];
    /**
     * Generate a string value
     */
    generateString(minLength?: number, maxLength?: number, pattern?: string): string;
    /**
     * Generate a number value
     */
    generateNumber(min?: number, max?: number): number;
    /**
     * Generate an integer value
     */
    generateInteger(min?: number, max?: number): number;
    /**
     * Generate a boolean value
     */
    generateBoolean(): boolean;
    /**
     * Generate a date value
     */
    generateDate(minYear?: number, maxYear?: number): Date;
    /**
     * Generate a datetime value
     */
    generateDatetime(minYear?: number, maxYear?: number): Date;
    /**
     * Generate an email address
     */
    generateEmail(): string;
    /**
     * Generate a URL
     */
    generateUrl(): string;
    /**
     * Generate a UUID
     */
    generateUuid(): string;
    /**
     * Generate an enum value
     */
    generateEnum(values: string[]): string;
    /**
     * Generate an array value
     */
    generateArray<T>(generator: () => T, minLength?: number, maxLength?: number): T[];
    /**
     * Generate XSS attack payloads
     */
    generateXssPayloads(): string[];
    /**
     * Generate SQL injection payloads
     */
    generateSqlInjectionPayloads(): string[];
    /**
     * Generate path traversal payloads
     */
    generatePathTraversalPayloads(): string[];
    /**
     * Generate overflow/boundary strings
     */
    generateOverflowStrings(): string[];
    private generateValidValue;
    private generateInvalidValue;
    private generateBoundaryValues;
    private generateFromPattern;
    private randomInt;
    private createSeededRng;
}
export declare const CommonSchemas: {
    user: {
        name: string;
        fields: ({
            name: string;
            type: FieldType;
            constraints?: undefined;
            nullable?: undefined;
            defaultValue?: undefined;
        } | {
            name: string;
            type: FieldType;
            constraints: {
                minLength: number;
                maxLength: number;
                min?: undefined;
                max?: undefined;
            };
            nullable?: undefined;
            defaultValue?: undefined;
        } | {
            name: string;
            type: FieldType;
            constraints: {
                min: number;
                max: number;
                minLength?: undefined;
                maxLength?: undefined;
            };
            nullable: boolean;
            defaultValue?: undefined;
        } | {
            name: string;
            type: FieldType;
            defaultValue: boolean;
            constraints?: undefined;
            nullable?: undefined;
        })[];
    };
    project: {
        name: string;
        fields: ({
            name: string;
            type: FieldType;
            constraints?: undefined;
            nullable?: undefined;
        } | {
            name: string;
            type: FieldType;
            constraints: {
                minLength: number;
                maxLength: number;
                enumValues?: undefined;
                min?: undefined;
                max?: undefined;
            };
            nullable?: undefined;
        } | {
            name: string;
            type: FieldType;
            constraints: {
                maxLength: number;
                minLength?: undefined;
                enumValues?: undefined;
                min?: undefined;
                max?: undefined;
            };
            nullable: boolean;
        } | {
            name: string;
            type: FieldType;
            constraints: {
                enumValues: string[];
                minLength?: undefined;
                maxLength?: undefined;
                min?: undefined;
                max?: undefined;
            };
            nullable?: undefined;
        } | {
            name: string;
            type: FieldType;
            constraints: {
                min: number;
                max: number;
                minLength?: undefined;
                maxLength?: undefined;
                enumValues?: undefined;
            };
            nullable?: undefined;
        })[];
    };
    testCase: {
        name: string;
        fields: ({
            name: string;
            type: FieldType;
            constraints: {
                pattern: string;
                minLength?: undefined;
                maxLength?: undefined;
                enumValues?: undefined;
                min?: undefined;
            };
            defaultValue?: undefined;
            nullable?: undefined;
        } | {
            name: string;
            type: FieldType;
            constraints: {
                minLength: number;
                maxLength: number;
                pattern?: undefined;
                enumValues?: undefined;
                min?: undefined;
            };
            defaultValue?: undefined;
            nullable?: undefined;
        } | {
            name: string;
            type: FieldType;
            constraints: {
                enumValues: string[];
                pattern?: undefined;
                minLength?: undefined;
                maxLength?: undefined;
                min?: undefined;
            };
            defaultValue?: undefined;
            nullable?: undefined;
        } | {
            name: string;
            type: FieldType;
            defaultValue: boolean;
            constraints?: undefined;
            nullable?: undefined;
        } | {
            name: string;
            type: FieldType;
            constraints: {
                min: number;
                pattern?: undefined;
                minLength?: undefined;
                maxLength?: undefined;
                enumValues?: undefined;
            };
            nullable: boolean;
            defaultValue?: undefined;
        })[];
    };
};
//# sourceMappingURL=test-data-factory.d.ts.map