/// <reference types="node" />
import { z } from "zod";
import { EventEmitter } from "events";
import { Options } from "./parse";
export interface CSVStreamError<T extends z.ZodType> {
    index: number;
    row: Record<string, string | undefined>;
    error: z.ZodError<T>;
}
interface CSVStreamEvents<T extends z.ZodType> {
    data: (data: z.infer<T>) => void;
    error: (error: CSVStreamError<T>) => void;
    end: () => void;
    headers: (headers: string[]) => void;
}
declare interface CSVStream<T extends z.ZodType> {
    on<E extends keyof CSVStreamEvents<T>>(event: E, listener: CSVStreamEvents<T>[E]): this;
    emit<E extends keyof CSVStreamEvents<T>>(event: E, ...args: Parameters<CSVStreamEvents<T>[E]>): boolean;
}
/**
 * A class that processes CSV data as a stream and emits events for parsed records
 */
declare class CSVStream<T extends z.ZodType> extends EventEmitter {
    private schema;
    private options?;
    private headers;
    private buffer;
    private rowIndex;
    private headersParsed;
    constructor(schema: T, options?: Options);
    /**
     * Write a chunk of CSV data to the stream
     * @param chunk - A chunk of CSV data
     */
    write(chunk: string): void;
    /**
     * End the stream and process any remaining data
     */
    end(): void;
    private processBuffer;
    /**
     * Find the position of a newline character that is not inside quoted content
     * This handles both regular quotes and escaped quotes
     */
    private findSafeNewlinePosition;
    private processRow;
}
/**
 * Process CSV data in chunks and emit events for parsed records
 * @param schema - Zod schema to validate each record against
 * @param options - CSV parsing options
 * @returns A function that accepts chunks of CSV data
 *
 * @example
 * ```ts
 * const processor = processCSVInChunks(schema);
 *
 * processor.on('data', (data) => {
 *   console.log('Valid row:', data);
 * });
 *
 * processor.on('error', ({ index, error }) => {
 *   console.log(`Invalid row at index ${index}:`, error);
 * });
 *
 * // Process chunks of data
 * processor.write('name,age\n');
 * processor.write('John,30\n');
 * processor.write('Jane,invalid\n');
 * processor.end();
 * ```
 */
export declare function processCSVInChunks<T extends z.ZodType>(schema: T, options?: Options): CSVStream<T>;
export {};