/**
 * CSV Data Generator
 *
 * A lightweight utility for generating random CSV data.
 * Useful for testing, benchmarking, and creating mock datasets.
 *
 * Features:
 * - Seeded pseudo-random number generation for reproducible results
 * - Built-in column types: string, int, float, bool, date, uuid, email, etc.
 * - Custom generator function support
 * - Sync and async iteration support
 * - Cross-platform (Node.js and Browser)
 */
/** Built-in column type names */
export type BuiltinColumnType = "string" | "int" | "float" | "bool" | "date" | "datetime" | "uuid" | "email" | "name" | "firstName" | "lastName" | "word" | "sentence" | "paragraph" | "phone" | "url" | "ip" | "ipv6" | "hex" | "index" | "company" | "country" | "currency" | "percent" | "timestamp" | "city" | "zipCode" | "color" | "username" | "slug";
/** Custom generator function */
export type GeneratorFn = (context: GeneratorContext) => unknown;
/** Column definition */
export type ColumnDef = BuiltinColumnType | GeneratorFn | GeneratorColumnConfig;
/** Detailed column configuration */
export interface GeneratorColumnConfig {
    /** Column type or custom generator */
    type: BuiltinColumnType | GeneratorFn;
    /** Column name (for header) */
    name?: string;
    /** Minimum value (for int/float) */
    min?: number;
    /** Maximum value (for int/float) */
    max?: number;
    /** Length or max length (for string types) */
    length?: number;
    /** Possible values to pick from */
    values?: unknown[];
    /** Null probability (0-1) */
    nullable?: number;
    /** Date range start */
    dateFrom?: Date;
    /** Date range end */
    dateTo?: Date;
}
/** Context passed to generator functions */
export interface GeneratorContext {
    /** Current row index (0-based) */
    rowIndex: number;
    /** Current column index (0-based) */
    colIndex: number;
    /** Column name if defined */
    colName?: string;
    /** Random number generator (0-1) */
    random: () => number;
    /** Random integer in range */
    randomInt: (min: number, max: number) => number;
    /** Random float in range */
    randomFloat: (min: number, max: number, precision?: number) => number;
    /** Random item from array */
    randomPick: <T>(arr: readonly T[]) => T;
    /** Random string of given length */
    randomString: (length: number) => string;
    /** Random date in range */
    randomDate: (from?: Date, to?: Date) => Date;
    /** Random boolean with probability */
    randomBool: (probability?: number) => boolean;
}
/** Stop condition for generation */
export type StopCondition = {
    rows: number;
} | {
    duration: number;
} | {
    until: Date | number;
} | {
    custom: (ctx: StopContext) => boolean;
};
/** Context for stop condition evaluation */
export interface StopContext {
    /** Number of rows generated so far */
    rowCount: number;
    /** Time elapsed since start (ms) */
    elapsed: number;
    /** Start time */
    startTime: number;
}
/** CSV generator options */
export interface CsvGenerateOptions {
    /** Column definitions (number for count, or array of definitions) */
    columns?: number | ColumnDef[];
    /**
     * Number of rows to generate.
     * Use Infinity or -1 for unlimited (must use iterator API).
     */
    rows?: number;
    /** Seed for reproducible random data */
    seed?: number;
    /** Include header row */
    headers?: boolean | string[];
    /** Field delimiter */
    delimiter?: string;
    /** Row delimiter (line ending) */
    lineEnding?: string;
    /**
     * Append string at end of output (e.g., "\n" for trailing newline).
     * Only applies to csvGenerate(), not iterators.
     */
    eof?: string;
    /**
     * Prepend UTF-8 BOM (Byte Order Mark) for Excel compatibility.
     * Only applies to csvGenerate(), not iterators.
     */
    bom?: boolean;
    /**
     * Output rows as objects with header keys instead of arrays.
     * Only applies to csvGenerateData().
     */
    objectMode?: boolean;
    /**
     * Transform function applied to each generated row.
     * Receives the row data and context, returns the transformed row.
     */
    transform?: (row: unknown[], context: {
        rowIndex: number;
        headers: string[];
    }) => unknown[];
    /**
     * Stop after duration milliseconds (for iterator APIs).
     * Takes precedence over rows if both specified.
     */
    duration?: number;
    /**
     * Stop at specific time (Date or timestamp).
     * Takes precedence over rows if specified.
     */
    until?: Date | number;
    /** Default string length */
    stringLength?: number;
    /** Default int range */
    intMin?: number;
    intMax?: number;
    /** Default float range */
    floatMin?: number;
    floatMax?: number;
    /** Default float precision */
    floatPrecision?: number;
    /**
     * Quoting strategy for CSV fields.
     * - 'auto': Quote only when necessary (default)
     * - 'always': Always quote all fields
     * - 'never': Never quote (may produce invalid CSV if data contains delimiters)
     */
    quote?: "auto" | "always" | "never";
    /**
     * Skip first N data rows (headers are not affected).
     * Useful for resuming generation or pagination.
     */
    skipRows?: number;
}
/** Result from generate function */
export interface CsvGenerateResult {
    /** Generated CSV string */
    csv: string;
    /** Header names */
    headers: string[];
    /** Data as 2D array */
    data: unknown[][];
}
/**
 * Generate CSV data synchronously.
 *
 * @example
 * ```ts
 * // Simple: 5 columns, 100 rows
 * const { csv } = csvGenerate({ columns: 5, rows: 100 });
 *
 * // With column types
 * const { csv, data } = csvGenerate({
 *   columns: ['name', 'email', 'int', 'bool', 'date'],
 *   rows: 50,
 *   headers: ['Name', 'Email', 'Age', 'Active', 'JoinDate']
 * });
 *
 * // With custom generators
 * const { csv } = csvGenerate({
 *   columns: [
 *     { type: 'int', min: 18, max: 65, name: 'age' },
 *     { type: 'float', min: 0, max: 100, name: 'score' },
 *     (ctx) => `row-${ctx.rowIndex}`,
 *   ],
 *   rows: 100,
 *   seed: 12345  // Reproducible
 * });
 * ```
 */
export declare function csvGenerate(options?: CsvGenerateOptions): CsvGenerateResult;
/**
 * Generate CSV rows as an iterator (memory efficient for large datasets).
 *
 * Supports unlimited generation with stop conditions:
 * - `rows: -1` or `rows: Infinity` for unlimited
 * - `duration: 5000` to generate for 5 seconds
 * - `until: new Date('2024-12-31')` to generate until specific time
 *
 * @example
 * ```ts
 * // Fixed number of rows
 * for (const row of csvGenerateRows({ columns: 5, rows: 1000000 })) {
 *   process.stdout.write(row + '\n');
 * }
 *
 * // Generate for 5 seconds
 * for (const row of csvGenerateRows({ columns: 3, duration: 5000 })) {
 *   console.log(row);
 * }
 *
 * // Unlimited with manual break
 * for (const row of csvGenerateRows({ columns: 3, rows: -1 })) {
 *   if (someCondition) break;
 *   console.log(row);
 * }
 * ```
 */
export declare function csvGenerateRows(options?: CsvGenerateOptions): Generator<string, void, undefined>;
/**
 * Generate CSV data as an async generator (useful for streaming with delays).
 *
 * Supports all stop conditions from csvGenerateRows plus delay between rows.
 *
 * @example
 * ```ts
 * // Generate with delay between rows
 * for await (const row of csvGenerateAsync({ columns: 5, rows: 100, delay: 10 })) {
 *   console.log(row);
 * }
 *
 * // Generate for 5 seconds with 100ms delay
 * for await (const row of csvGenerateAsync({ columns: 3, duration: 5000, delay: 100 })) {
 *   console.log(row);
 * }
 * ```
 */
export declare function csvGenerateAsync(options?: CsvGenerateOptions & {
    delay?: number;
}): AsyncGenerator<string, void, undefined>;
/**
 * Generate raw data rows (without CSV formatting).
 *
 * @example
 * ```ts
 * const rows = csvGenerateData({
 *   columns: ['name', 'int', 'email'],
 *   rows: 10
 * });
 * // Returns: [['John Smith', 42, 'abc@gmail.com'], ...]
 *
 * // With objectMode
 * const objects = csvGenerateData({
 *   columns: [{ type: 'name', name: 'fullName' }, { type: 'int', name: 'age' }],
 *   rows: 10,
 *   objectMode: true
 * });
 * // Returns: [{ fullName: 'John Smith', age: 42 }, ...]
 * ```
 */
export declare function csvGenerateData<T extends CsvGenerateOptions>(options?: T): T extends {
    objectMode: true;
} ? Record<string, unknown>[] : unknown[][];
/**
 * Create a reusable generator instance with preset configuration.
 *
 * @example
 * ```ts
 * const gen = createCsvGenerator({
 *   columns: ['name', 'email', { type: 'int', min: 18, max: 99 }],
 *   seed: 42
 * });
 *
 * // Generate multiple batches with same config
 * const batch1 = gen.generate(100);
 * const batch2 = gen.generate(100);
 *
 * // Generate for 5 seconds
 * for (const row of gen.rows({ duration: 5000 })) {
 *   console.log(row);
 * }
 * ```
 */
export declare function createCsvGenerator(baseOptions?: CsvGenerateOptions): {
    /**
     * Generate CSV synchronously
     */
    generate(rowsOrOptions?: number | Partial<CsvGenerateOptions>): CsvGenerateResult;
    /**
     * Generate CSV rows as iterator
     */
    rows(rowsOrOptions?: number | Partial<CsvGenerateOptions>): Generator<string, void, undefined>;
    /**
     * Generate raw data array
     */
    data<O extends Partial<CsvGenerateOptions>>(rowsOrOptions?: number | O): O extends {
        objectMode: true;
    } ? Record<string, unknown>[] : unknown[][];
    /**
     * Generate CSV rows as async iterator
     */
    asyncRows(options?: Partial<CsvGenerateOptions> & {
        delay?: number;
    }): AsyncGenerator<string, void, undefined>;
};