import { AggregateTemplate, SequenceGenerator, ValueObjectGenerator } from './aggregate-factory.js';
import { DomainSeederConfig, ISeeder, IStreamingSeeder, SeederResult, SeedableAggregate } from './shared-seeder-types.js';
/**
 * Configuration for aggregate-specific seeding behavior
 */
export interface AggregateSeederConfig {
    /** Enable automatic domain event generation */
    generateDomainEvents?: boolean;
    /** Enable capability-based seeding (audit trails, versioning, etc.) */
    enableCapabilities?: boolean;
    /** List of specific capabilities to enable */
    capabilities?: string[];
    /** Enable cross-aggregate relationship seeding */
    enableRelationships?: boolean;
    /** Batch size for streaming operations */
    streamingBatchSize?: number;
}
/**
 * Relationship configuration between aggregates
 */
export interface AggregateRelationship {
    /** Target aggregate type name */
    targetAggregate: string;
    /** Relationship type (one-to-one, one-to-many, many-to-many) */
    type: 'one-to-one' | 'one-to-many' | 'many-to-many';
    /** Minimum number of related entities */
    min?: number;
    /** Maximum number of related entities */
    max?: number;
    /** Average number of related entities for realistic distribution */
    average?: number;
    /** Probability that this relationship exists (0-1) */
    probability?: number;
}
/**
 * Event generation pattern for aggregate events
 */
export interface EventPattern {
    /** Event type name */
    eventType: string;
    /** Probability this event is generated (0-1) */
    probability?: number;
    /** Data generator for event payload */
    dataGenerator?: () => any | Promise<any>;
    /** Delay after aggregate creation (in ms) */
    delay?: number;
}
/**
 * Aggregate seeder implementation that provides a fluent API for type-safe
 * aggregate generation with deep DDD pattern integration.
 *
 * This seeder works closely with AggregateFactory to provide:
 * - Type-safe aggregate creation with business rule validation
 * - Capability-aware seeding for audit, versioning, and other patterns
 * - Domain event generation with realistic timelines
 * - Cross-aggregate relationship management
 * - Streaming support for large-scale data generation
 */
export declare class AggregateSeeder<T extends SeedableAggregate> implements ISeeder<T>, IStreamingSeeder<T> {
    private readonly factory;
    private readonly config;
    private readonly relationships;
    private readonly eventPatterns;
    /**
     * Creates a new AggregateSeeder instance.
     *
     * @param AggregateClass Constructor for the aggregate type
     * @param globalConfig Global seeder configuration
     */
    constructor(AggregateClass: new (...args: any[]) => T, globalConfig?: DomainSeederConfig);
    /**
     * Sets default values for aggregate properties.
     *
     * @param defaults Object containing default property values
     * @returns Seeder instance for method chaining
     */
    withDefaults(defaults: Partial<any>): this;
    /**
     * Adds a sequence generator for a specific property.
     *
     * @param property Property name to generate sequence values for
     * @param generator Function that generates sequential values
     * @returns Seeder instance for method chaining
     */
    withSequence<K extends keyof any>(property: K, generator: SequenceGenerator<any[K]>): this;
    /**
     * Adds a value object generator for a specific property.
     *
     * @param property Property name to generate value objects for
     * @param generator Function that creates value objects
     * @returns Seeder instance for method chaining
     */
    withValueObject<K extends keyof any>(property: K, generator: ValueObjectGenerator<any[K]>): this;
    /**
     * Configures aggregate capabilities for seeding.
     *
     * @param capabilities Array of capability names to enable
     * @returns Seeder instance for method chaining
     *
     * @example
     * ```typescript
     * const seeder = DomainSeeder.forAggregate(OrderAggregate)
     *   .withCapabilities(['audit', 'versioning', 'events'])
     *   .withDefaults({ status: 'draft' });
     * ```
     */
    withCapabilities(capabilities: string[]): this;
    /**
     * Configures domain event generation patterns.
     *
     * @param enable Whether to enable event generation
     * @param patterns Optional specific event patterns to generate
     * @returns Seeder instance for method chaining
     *
     * @example
     * ```typescript
     * const seeder = DomainSeeder.forAggregate(UserAggregate)
     *   .withEvents(true, [
     *     { eventType: 'UserRegistered', probability: 1.0 },
     *     { eventType: 'EmailVerified', probability: 0.8, delay: 1000 },
     *     { eventType: 'ProfileCompleted', probability: 0.6, delay: 5000 }
     *   ]);
     * ```
     */
    withEvents(enable: boolean, patterns?: EventPattern[]): this;
    /**
     * Configures relationships with other aggregates.
     *
     * @param relationshipName Name of the relationship
     * @param relationship Relationship configuration
     * @returns Seeder instance for method chaining
     *
     * @example
     * ```typescript
     * const orderSeeder = DomainSeeder.forAggregate(OrderAggregate)
     *   .withRelationship('orderItems', {
     *     targetAggregate: 'OrderItem',
     *     type: 'one-to-many',
     *     min: 1,
     *     max: 10,
     *     average: 3,
     *     probability: 1.0
     *   })
     *   .withRelationship('customer', {
     *     targetAggregate: 'Customer',
     *     type: 'one-to-one',
     *     probability: 1.0
     *   });
     * ```
     */
    withRelationship(relationshipName: string, relationship: AggregateRelationship): this;
    /**
     * Registers a reusable template for aggregate creation.
     *
     * @param template Template configuration
     * @returns Seeder instance for method chaining
     */
    withTemplate(template: AggregateTemplate<any>): this;
    /**
     * Adds a post-processor for aggregate modification after creation.
     *
     * @param processor Async function to process the aggregate
     * @returns Seeder instance for method chaining
     */
    withPostProcessor(processor: (aggregate: T) => Promise<T>): this;
    /**
     * Builds a single aggregate instance.
     *
     * @param overrides Optional property overrides
     * @param templateName Optional template to use
     * @returns Promise resolving to created aggregate
     */
    build(overrides?: Partial<any>, templateName?: string): Promise<SeederResult<T>>;
    /**
     * Builds multiple aggregate instances.
     *
     * @param count Number of aggregates to create
     * @param overrideGenerator Optional per-instance override generator
     * @param templateName Optional template to use
     * @returns Promise resolving to array of aggregates
     */
    buildMany(count: number, overrideGenerator?: (index: number) => Partial<any>, templateName?: string): Promise<SeederResult<T[]>>;
    /**
     * Creates a streaming iterator for large-scale aggregate generation.
     *
     * @param count Total number of aggregates to generate
     * @param batchSize Optional batch size (defaults to config value)
     * @returns Async iterable of aggregate batches
     *
     * @example
     * ```typescript
     * const seeder = DomainSeeder.forAggregate(UserAggregate);
     *
     * // Stream 1 million users in batches of 1000
     * for await (const batch of seeder.stream(1_000_000, 1000)) {
     *   if (batch.success) {
     *     await saveToDatabase(batch.data);
     *   } else {
     *     console.error('Batch failed:', batch.error);
     *   }
     * }
     * ```
     */
    stream(count: number, batchSize?: number): AsyncIterable<SeederResult<T>>;
    /**
     * Gets current configuration.
     */
    getConfig(): Readonly<AggregateSeederConfig>;
    /**
     * Gets registered relationships.
     */
    getRelationships(): Map<string, AggregateRelationship>;
    /**
     * Gets configured event patterns.
     */
    getEventPatterns(): EventPattern[];
    /**
     * Applies capability-specific processing to an aggregate.
     */
    private applyCapabilities;
    /**
     * Generates domain events based on configured patterns.
     */
    private generateDomainEvents;
    /**
     * Applies post-processing to a created aggregate.
     */
    private postProcessAggregate;
}