/**
 * Streaming utilities for handling large result sets
 * Implements streaming responses for better performance and memory usage
 */
export interface StreamingOptions {
    batchSize?: number;
    delay?: number;
    transformItem?: (item: unknown) => unknown;
    filterItem?: (item: unknown) => boolean;
}
export interface StreamingResult<T> {
    data: T[];
    hasMore: boolean;
    cursor?: string | undefined;
    total?: number | undefined;
    processed: number;
}
/**
 * Creates a streaming response for large datasets
 */
export declare class DataStreamer<T> {
    private batchSize;
    private delay;
    private transformItem;
    private filterItem;
    constructor(options?: StreamingOptions);
    /**
     * Processes data in batches with streaming
     */
    streamBatches<U>(data: T[], processor: (batch: T[]) => Promise<U[]>): AsyncGenerator<StreamingResult<U>, void, unknown>;
    /**
     * Processes large datasets with pagination
     */
    streamPages<U>(fetcher: (page: number, perPage: number) => Promise<{
        data: T[];
        hasMore: boolean;
    }>, processor: (items: T[]) => Promise<U[]>): AsyncGenerator<StreamingResult<U>, void, unknown>;
}
/**
 * Streaming formatter for WordPress data
 */
export declare class WordPressDataStreamer {
    /**
     * Streams WordPress posts with author and taxonomy information
     */
    static streamPosts(posts: unknown[], options?: {
        includeAuthor?: boolean;
        includeCategories?: boolean;
        includeTags?: boolean;
        batchSize?: number;
    }): AsyncGenerator<StreamingResult<unknown>, void, unknown>;
    /**
     * Streams WordPress users with role information
     */
    static streamUsers(users: unknown[], options?: {
        includeRoles?: boolean;
        includeCapabilities?: boolean;
        batchSize?: number;
    }): AsyncGenerator<StreamingResult<unknown>, void, unknown>;
    /**
     * Streams WordPress comments with moderation status
     */
    static streamComments(comments: unknown[], options?: {
        includeAuthor?: boolean;
        includePost?: boolean;
        batchSize?: number;
    }): AsyncGenerator<StreamingResult<unknown>, void, unknown>;
}
/**
 * Utility functions for streaming responses
 */
export declare class StreamingUtils {
    /**
     * Formats streaming results for display
     */
    static formatStreamingResponse(results: StreamingResult<unknown>[], type?: "posts" | "users" | "comments" | "media"): string;
    /**
     * Implements progressive loading for large datasets
     */
    static loadProgressively<T>(fetcher: (offset: number, limit: number) => Promise<T[]>, options?: {
        initialLoad?: number;
        batchSize?: number;
        maxItems?: number;
        onProgress?: (loaded: number, total?: number) => void;
    }): Promise<T[]>;
}
/**
 * Memory-efficient data processor
 */
export declare class MemoryEfficientProcessor {
    /**
     * Processes large datasets with memory monitoring
     */
    static processLargeDataset<T, U>(dataProvider: () => AsyncGenerator<T[], void, unknown>, processor: (items: T[]) => Promise<U[]>, options?: {
        maxMemoryUsage?: number;
        batchSize?: number;
        onProgress?: (processed: number) => void;
    }): Promise<U[]>;
    /**
     * Helper method to split arrays into chunks
     */
    private static chunkArray;
}
//# sourceMappingURL=streaming.d.ts.map