@flow-conductor/core 1.0.0

package/build/index.d.ts

@@ -0,0 +1,674 @@
+/**
+ * Handler function for processing errors that occur during request execution.
+ *
+ * @param error - The error that occurred
+ */
+interface ErrorHandler {
+    (error: Error): void;
+}
+/**
+ * Handler function for processing successful request results.
+ *
+ * @template T - The type of result being handled
+ * @param result - The result to process
+ */
+interface ResultHandler<T = unknown> {
+    (result: T): void;
+}
+/**
+ * Handler function for processing chunks of data as they arrive from streaming responses.
+ * This enables progressive processing of large responses without loading everything into memory.
+ *
+ * @template Chunk - The type of chunk data being processed
+ * @param chunk - The chunk of data to process
+ * @param metadata - Optional metadata about the chunk (index, total size, etc.)
+ * @returns A promise that resolves when chunk processing is complete (optional)
+ *
+ * @example
+ * ```typescript
+ * chunkHandler: async (chunk, metadata) => {
+ *   console.log(`Processing chunk ${metadata.index}:`, chunk);
+ *   await processChunk(chunk);
+ * }
+ * ```
+ */
+interface ChunkHandler<Chunk = unknown> {
+    (chunk: Chunk, metadata?: {
+        index: number;
+        isLast: boolean;
+        totalBytesRead?: number;
+    }): void | Promise<void>;
+}
+
+/**
+ * Abstract base class for managing request pipelines and flows.
+ * Provides functionality for chaining requests, error handling, and result processing.
+ *
+ * @template Out - The output type of the request flow
+ * @template AdapterExecutionResult - The type of result returned by the adapter
+ * @template RequestConfig - The type of request configuration, must extend IRequestConfig
+ */
+declare abstract class RequestFlow<Out, AdapterExecutionResult = Out, RequestConfig extends IRequestConfig = IRequestConfig> {
+    /**
+     * List of pipeline stages to execute
+     */
+    protected requestList: (PipelineRequestStage<any, any, any> | PipelineManagerStage<any, any, any>)[];
+    /**
+     * Optional error handler callback
+     */
+    protected errorHandler?: ErrorHandler;
+    /**
+     * Optional result handler callback
+     */
+    protected resultHandler?: ResultHandler<Out | Out[]>;
+    /**
+     * Optional finish handler callback executed after completion
+     */
+    protected finishHandler?: () => void;
+    /**
+     * The request adapter used to execute HTTP requests
+     */
+    protected adapter: RequestAdapter<AdapterExecutionResult, RequestConfig>;
+    /**
+     * Executes the request flow and returns the final result.
+     * Must be implemented by concrete subclasses.
+     *
+     * @returns A promise that resolves to the output result
+     */
+    abstract execute(): Promise<Out>;
+    /**
+     * Sets the request adapter to use for executing HTTP requests.
+     *
+     * @param adapter - The request adapter instance
+     * @returns The current RequestFlow instance for method chaining
+     */
+    setRequestAdapter(adapter: RequestAdapter<AdapterExecutionResult, RequestConfig>): RequestFlow<Out, AdapterExecutionResult, RequestConfig>;
+    /**
+     * Adds multiple pipeline stages to the request list.
+     *
+     * @param requestList - Array of pipeline stages to add
+     * @returns The current RequestFlow instance for method chaining
+     */
+    addAll(requestList?: Array<PipelineRequestStage<AdapterExecutionResult, Out, RequestConfig> | PipelineManagerStage<Out, AdapterExecutionResult, RequestConfig>>): RequestFlow<Out, AdapterExecutionResult, RequestConfig>;
+    /**
+     * Sets an error handler callback that will be called when an error occurs during execution.
+     *
+     * @param errorHandler - Function to handle errors
+     * @returns The current RequestFlow instance for method chaining
+     */
+    withErrorHandler(errorHandler: ErrorHandler): RequestFlow<Out, AdapterExecutionResult, RequestConfig>;
+    /**
+     * Sets a result handler callback that will be called with the execution result.
+     *
+     * @param resultHandler - Function to handle results
+     * @returns The current RequestFlow instance for method chaining
+     */
+    withResultHandler(resultHandler: ResultHandler<Out | Out[]>): RequestFlow<Out, AdapterExecutionResult, RequestConfig>;
+    /**
+     * Sets a finish handler callback that will be called after execution completes (success or failure).
+     *
+     * @param finishHandler - Function to execute on completion
+     * @returns The current RequestFlow instance for method chaining
+     */
+    withFinishHandler(finishHandler: () => void): RequestFlow<Out, AdapterExecutionResult, RequestConfig>;
+}
+
+/**
+ * Supported HTTP methods for requests
+ */
+type HttpMethods = "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | "HEAD" | "OPTIONS" | "CONNECT" | "TRACE";
+/**
+ * Base interface for HTTP request configuration.
+ * Extend this interface to add adapter-specific configuration options.
+ *
+ * @example
+ * ```typescript
+ * interface MyRequestConfig extends IRequestConfig {
+ *   timeout?: number;
+ *   retries?: number;
+ * }
+ * ```
+ */
+interface IRequestConfig {
+    /** Optional request ID */
+    id?: string;
+    /** The URL to make the request to */
+    url: string;
+    /** The HTTP method to use */
+    method: HttpMethods;
+    /** Optional request body data */
+    data?: any;
+    /** Additional adapter-specific configuration options */
+    [key: string]: any;
+}
+/**
+ * Factory function type for creating request configurations dynamically based on previous results.
+ *
+ * @template Result - The type of the previous result
+ * @template AdapterRequestConfig - The type of request configuration to create
+ * @param previousResult - The result from the previous pipeline stage (optional)
+ * @returns The request configuration object
+ */
+type IRequestConfigFactory<Result, AdapterRequestConfig extends IRequestConfig = IRequestConfig> = (previousResult?: Result) => AdapterRequestConfig;
+/**
+ * Configuration for retry behavior when a request fails.
+ *
+ * @example
+ * ```typescript
+ * // Retry on network errors and 5xx status codes
+ * retry: {
+ *   maxRetries: 3,
+ *   retryDelay: 1000,
+ *   exponentialBackoff: true,
+ *   maxDelay: 10000,
+ *   retryCondition: (error, attempt) => {
+ *     // Retry on network errors
+ *     if (error.name === 'TypeError' || error.name === 'NetworkError') {
+ *       return true;
+ *     }
+ *     // Retry on 5xx and 429 status codes
+ *     const status = getErrorStatus(error);
+ *     return status !== undefined && (status >= 500 || status === 429);
+ *   }
+ * }
+ * ```
+ */
+interface RetryConfig {
+    /**
+     * Maximum number of retry attempts. Defaults to 3.
+     */
+    maxRetries?: number;
+    /**
+     * Delay between retries in milliseconds.
+     * Can be a fixed number or a function that calculates delay based on attempt number and error.
+     * Defaults to 1000ms.
+     *
+     * @example
+     * ```typescript
+     * // Fixed delay
+     * retryDelay: 2000
+     *
+     * // Custom delay function
+     * retryDelay: (attempt, error) => attempt * 1000
+     *
+     * // Exponential backoff (use exponentialBackoff: true instead)
+     * retryDelay: (attempt) => Math.min(1000 * Math.pow(2, attempt), 10000)
+     * ```
+     */
+    retryDelay?: number | ((attempt: number, error: Error) => number);
+    /**
+     * Whether to use exponential backoff for retry delays.
+     * When true, delays will be: delay * 2^attempt, capped at maxDelay if provided.
+     * Defaults to false.
+     */
+    exponentialBackoff?: boolean;
+    /**
+     * Maximum delay cap in milliseconds when using exponential backoff.
+     * Prevents delays from growing too large.
+     * Only applies when exponentialBackoff is true.
+     */
+    maxDelay?: number;
+    /**
+     * Function that determines whether to retry based on the error and attempt number.
+     * Return true to retry, false to stop retrying.
+     * If not provided, defaults to retrying on network errors only.
+     *
+     * @param error - The error that occurred
+     * @param attempt - The current attempt number (0-indexed, so first retry is attempt 1)
+     * @returns True if the request should be retried, false otherwise
+     */
+    retryCondition?: (error: Error, attempt: number) => boolean;
+}
+/**
+ * Base interface for pipeline stages.
+ * Defines common properties shared by all pipeline stage types.
+ *
+ * @template Result - The type of result from the stage
+ * @template Out - The output type after mapping (defaults to Result)
+ * @template PrevOut - The output type of the previous stage (defaults to Out for backward compatibility)
+ */
+interface BasePipelineStage<Result, Out = Result, PrevOut = Out> {
+    /**
+     * Optional precondition function. If provided and returns false, the stage will be skipped.
+     */
+    precondition?: () => boolean;
+    /**
+     * The result produced by this stage (set after execution)
+     */
+    result?: Out;
+    /**
+     * Optional mapper function to transform the stage result.
+     * Can return a value or a promise.
+     * @param result - The result from the current stage
+     * @param prev - The result from the previous stage (undefined for the first stage)
+     */
+    mapper?: (result: Result, prev?: PrevOut) => Out | Promise<Out>;
+    /**
+     * Optional result interceptor function to process the stage result.
+     * Can be used to perform additional actions on the result.
+     * @param result - The result from the stage
+     */
+    resultInterceptor?: (result: Out) => void | Promise<void>;
+    /**
+     * Optional error handler function to process the stage error.
+     * Can be used to perform additional actions on the error.
+     * @param error - The error from the stage
+     */
+    errorHandler?: (error: Error) => void | Promise<void>;
+}
+/**
+ * Configuration for progressive chunk processing of streaming responses.
+ * Enables processing large responses incrementally without loading everything into memory.
+ *
+ * @example
+ * ```typescript
+ * chunkProcessing: {
+ *   enabled: true,
+ *   chunkHandler: async (chunk, metadata) => {
+ *     console.log(`Chunk ${metadata.index}:`, chunk);
+ *     await processChunk(chunk);
+ *   },
+ *   chunkSize: 1024, // Process in 1KB chunks
+ *   encoding: 'utf-8'
+ * }
+ * ```
+ */
+interface ChunkProcessingConfig<Chunk = string | Uint8Array> {
+    /**
+     * Whether chunk processing is enabled. Defaults to false.
+     * When enabled, the response body will be processed as a stream.
+     */
+    enabled: boolean;
+    /**
+     * Handler function called for each chunk as it arrives.
+     * Required when chunk processing is enabled.
+     */
+    chunkHandler: ChunkHandler<Chunk>;
+    /**
+     * Size of each chunk in bytes. Only applies to binary data.
+     * For text streams, chunks are delimited by newlines or the stream.
+     * Defaults to 8192 (8KB).
+     */
+    chunkSize?: number;
+    /**
+     * Text encoding for text-based streams. Defaults to 'utf-8'.
+     * Ignored for binary streams.
+     * Common values: 'utf-8', 'utf-16', 'ascii', etc.
+     */
+    encoding?: string;
+    /**
+     * Whether to accumulate chunks and return them as a complete result.
+     * When false, only the chunk handler is called and the final result may be empty.
+     * Defaults to false.
+     */
+    accumulate?: boolean;
+}
+/**
+ * Pipeline stage that executes an HTTP request using the adapter.
+ *
+ * @template Result - The type of result from the adapter
+ * @template Out - The output type after mapping (defaults to Result)
+ * @template AdapterRequestConfig - The type of request configuration
+ * @template PrevOut - The output type of the previous stage (defaults to Out for backward compatibility)
+ */
+interface PipelineRequestStage<Result, Out = Result, AdapterRequestConfig extends IRequestConfig = IRequestConfig, PrevOut = Out> extends BasePipelineStage<Result, Out, PrevOut> {
+    /**
+     * Request configuration. Can be a static config object or a factory function
+     * that creates the config based on previous results.
+     */
+    config: AdapterRequestConfig | IRequestConfigFactory<PrevOut, AdapterRequestConfig>;
+    /**
+     * Optional retry configuration for handling request failures.
+     * Only applies to request stages, not nested manager stages.
+     */
+    retry?: RetryConfig;
+    /**
+     * Optional chunk processing configuration for progressive processing of streaming responses.
+     * Enables processing large responses incrementally without loading everything into memory.
+     * Only applies to request stages that support streaming (e.g., Fetch API with ReadableStream).
+     */
+    chunkProcessing?: ChunkProcessingConfig;
+}
+/**
+ * Pipeline stage that executes a nested request flow/chain.
+ *
+ * @template Out - The output type of the nested request flow
+ * @template AdapterExecutionResult - The type of result returned by the adapter
+ * @template AdapterRequestConfig - The type of request configuration
+ * @template PrevOut - The output type of the previous stage (defaults to Out for backward compatibility)
+ */
+interface PipelineManagerStage<Out, AdapterExecutionResult, AdapterRequestConfig extends IRequestConfig = IRequestConfig, PrevOut = Out> extends BasePipelineStage<Out, Out, PrevOut> {
+    /**
+     * The nested request flow to execute
+     */
+    request: RequestFlow<Out, AdapterExecutionResult, AdapterRequestConfig>;
+}
+
+/**
+ * URL validation utilities to prevent SSRF (Server-Side Request Forgery) attacks
+ */
+interface UrlValidationOptions {
+    /**
+     * Allow private/internal IP addresses (default: false)
+     * WARNING: Enabling this can expose your application to SSRF attacks
+     */
+    allowPrivateIPs?: boolean;
+    /**
+     * Allow localhost addresses (default: false)
+     * WARNING: Enabling this can expose your application to SSRF attacks
+     */
+    allowLocalhost?: boolean;
+    /**
+     * Custom list of allowed protocols (default: ['http:', 'https:'])
+     */
+    allowedProtocols?: string[];
+    /**
+     * Disable URL validation entirely (default: false)
+     * WARNING: This completely disables SSRF protection
+     */
+    disableValidation?: boolean;
+}
+declare class SSRFError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validates a URL to prevent SSRF attacks
+ * @param url - The URL to validate
+ * @param options - Validation options
+ * @throws {SSRFError} If the URL is invalid or potentially dangerous
+ */
+declare function validateUrl(url: string, options?: UrlValidationOptions): void;
+
+/**
+ * Abstract base class for request adapters that handle HTTP requests.
+ * Provides URL validation and a common interface for different HTTP client implementations.
+ *
+ * @template ExecutionResult - The type of result returned by the adapter's HTTP client
+ * @template RequestConfig - The type of request configuration, must extend IRequestConfig
+ *
+ * @example
+ * ```typescript
+ * class MyAdapter extends RequestAdapter<Response> {
+ *   async createRequest(config: IRequestConfig): Promise<Response> {
+ *     // Implementation
+ *   }
+ * }
+ * ```
+ */
+declare abstract class RequestAdapter<ExecutionResult, RequestConfig extends IRequestConfig = IRequestConfig> {
+    /**
+     * URL validation options used to prevent SSRF attacks
+     */
+    protected urlValidationOptions: UrlValidationOptions;
+    /**
+     * Creates a new RequestAdapter instance.
+     *
+     * @param urlValidationOptions - Options for URL validation to prevent SSRF attacks
+     */
+    constructor(urlValidationOptions?: UrlValidationOptions);
+    /**
+     * Creates and executes an HTTP request using the adapter's underlying HTTP client.
+     * This method must be implemented by concrete adapter classes.
+     *
+     * @param requestConfig - The request configuration object
+     * @returns A promise that resolves to the execution result
+     */
+    abstract createRequest(requestConfig: RequestConfig): Promise<ExecutionResult>;
+    /**
+     * Type-safe getter for the execution result.
+     * Allows casting the result to a specific type.
+     *
+     * @template T - The desired result type
+     * @param result - The execution result to cast
+     * @returns The result cast to type T
+     */
+    getResult<T extends ExecutionResult>(result: ExecutionResult): T;
+    /**
+     * Executes a request with URL validation.
+     * Validates the URL to prevent SSRF attacks before creating the request.
+     *
+     * @param requestConfig - The request configuration object
+     * @returns A promise that resolves to the execution result
+     * @throws {SSRFError} If the URL is invalid or potentially dangerous
+     */
+    executeRequest(requestConfig: RequestConfig): Promise<ExecutionResult>;
+}
+
+/**
+ * A chainable request pipeline that allows sequential execution of HTTP requests.
+ * Each stage can depend on the result of the previous stage, and stages can be conditionally executed.
+ *
+ * @template Out - The output type of the current chain
+ * @template AdapterExecutionResult - The type of result returned by the adapter
+ * @template AdapterRequestConfig - The type of request configuration
+ * @template Types - Tuple type tracking all output types in the chain
+ *
+ * @example
+ * ```typescript
+ * const chain = RequestChain.begin(
+ *   { config: { url: 'https://api.example.com/users', method: 'GET' } },
+ *   adapter
+ * ).next({ config: { url: 'https://api.example.com/posts', method: 'GET' } });
+ *
+ * const result = await chain.execute();
+ * ```
+ */
+declare class RequestChain<Out, AdapterExecutionResult = Out, AdapterRequestConfig extends IRequestConfig = IRequestConfig, Types extends readonly unknown[] = [Out]> extends RequestFlow<Out, AdapterExecutionResult, AdapterRequestConfig> {
+    /**
+     * Creates a new RequestChain with an initial stage.
+     * This is the entry point for building a request chain.
+     *
+     * @template Out - The output type of the initial stage
+     * @template AdapterExecutionResult - The type of result returned by the adapter
+     * @template AdapterRequestConfig - The type of request configuration
+     * @param stage - The initial pipeline stage (request or manager stage)
+     * @param adapter - The request adapter to use for HTTP requests
+     * @returns A new RequestChain instance with the initial stage
+     */
+    static begin: <Out_1, AdapterExecutionResult_1, AdapterRequestConfig_1 extends IRequestConfig = IRequestConfig>(stage: PipelineRequestStage<AdapterExecutionResult_1, Out_1, AdapterRequestConfig_1> | PipelineManagerStage<Out_1, AdapterExecutionResult_1, AdapterRequestConfig_1>, adapter: RequestAdapter<AdapterExecutionResult_1, AdapterRequestConfig_1>) => RequestChain<Out_1, AdapterExecutionResult_1, AdapterRequestConfig_1, [Out_1]>;
+    /**
+     * Adds a new stage to the request chain and returns a new chain with updated types.
+     * This method enables type-safe chaining of requests.
+     *
+     * @template NewOut - The output type of the new stage
+     * @param stage - The pipeline stage to add (request or manager stage)
+     * @returns A new RequestChain instance with the added stage
+     */
+    next: <NewOut>(stage: PipelineRequestStage<AdapterExecutionResult, NewOut, AdapterRequestConfig, Out> | PipelineManagerStage<NewOut, AdapterExecutionResult, AdapterRequestConfig, Out>) => RequestChain<NewOut, AdapterExecutionResult, AdapterRequestConfig, [...Types, NewOut]>;
+    /**
+     * Executes all stages in the chain sequentially and returns the final result.
+     * Handles errors and calls registered handlers appropriately.
+     *
+     * @returns A promise that resolves to the final output result
+     * @throws {Error} If an error occurs and no error handler is registered
+     */
+    execute: () => Promise<Out>;
+    /**
+     * Executes all stages in the chain and returns all results as a tuple.
+     * Useful when you need access to intermediate results.
+     *
+     * @returns A promise that resolves to a tuple of all stage results
+     * @throws {Error} If an error occurs and no error handler is registered
+     */
+    executeAll(): Promise<Types>;
+    /**
+     * Adds a request entity (stage) to the internal request list.
+     *
+     * @template NewOut - The output type of the new stage
+     * @param stage - The pipeline stage to add
+     * @returns A new RequestChain instance with updated types
+     */
+    private addRequestEntity;
+    /**
+     * Executes all request entities in sequence, handling preconditions and mappers.
+     * Stages with failed preconditions are skipped but preserve the previous result.
+     *
+     * @template Out - The output type
+     * @param requestEntityList - List of pipeline stages to execute
+     * @returns A promise that resolves to an array of all stage results
+     */
+    private executeAllRequests;
+    /**
+     * Executes a single request entity (stage).
+     * Handles both request stages and nested manager stages.
+     * Implements retry logic for request stages when retry configuration is provided.
+     * Supports progressive chunk processing for streaming responses.
+     *
+     * @template Out - The output type
+     * @param requestEntity - The pipeline stage to execute
+     * @param previousResult - The result from the previous stage (optional)
+     * @returns A promise that resolves to the stage result
+     * @throws {Error} If the stage type is unknown or all retries are exhausted
+     */
+    private executeSingle;
+    /**
+     * Executes a request with retry logic based on the provided retry configuration.
+     * Supports chunk processing for streaming responses.
+     *
+     * @template Out - The output type
+     * @param requestConfig - The request configuration
+     * @param retryConfig - The retry configuration
+     * @param chunkProcessing - Optional chunk processing configuration
+     * @returns A promise that resolves to the request result
+     * @throws {Error} If all retry attempts are exhausted
+     */
+    private executeWithRetry;
+    /**
+     * Processes a result with chunk processing if enabled.
+     * Handles streaming responses by processing chunks progressively.
+     *
+     * @template Out - The output type
+     * @param rawResult - The raw result from the adapter
+     * @param chunkProcessing - Optional chunk processing configuration
+     * @returns A promise that resolves to the processed result
+     */
+    private processResultWithChunks;
+    /**
+     * Calculates the delay before the next retry attempt.
+     *
+     * @param attempt - The current attempt number (1-indexed for retries)
+     * @param error - The error that occurred
+     * @param retryConfig - The retry configuration
+     * @returns The delay in milliseconds
+     */
+    private calculateRetryDelay;
+    /**
+     * Sleeps for the specified number of milliseconds.
+     *
+     * @param ms - Milliseconds to sleep
+     * @returns A promise that resolves after the delay
+     */
+    private sleep;
+}
+/**
+ * Creates a new RequestChain with an initial stage.
+ * This is a convenience function that wraps RequestChain.begin.
+ *
+ * @template Out - The output type of the initial stage
+ * @template AdapterExecutionResult - The type of result returned by the adapter
+ * @template AdapterRequestConfig - The type of request configuration
+ * @param stage - The initial pipeline stage (request or manager stage)
+ * @param adapter - The request adapter to use for HTTP requests
+ * @returns A new RequestChain instance with the initial stage
+ */
+declare function begin<Out, AdapterExecutionResult, AdapterRequestConfig extends IRequestConfig = IRequestConfig>(stage: PipelineRequestStage<AdapterExecutionResult, Out, AdapterRequestConfig> | PipelineManagerStage<Out, AdapterExecutionResult, AdapterRequestConfig>, adapter: RequestAdapter<AdapterExecutionResult, AdapterRequestConfig>): RequestChain<Out, AdapterExecutionResult, AdapterRequestConfig, [Out]>;
+
+/**
+ * Utility functions for retry logic and error handling.
+ */
+/**
+ * Attempts to extract HTTP status code from an error object.
+ * Works with different adapter error formats (Axios, Fetch, etc.).
+ *
+ * @param error - The error object
+ * @returns The HTTP status code if available, undefined otherwise
+ */
+declare function getErrorStatus(error: Error): number | undefined;
+/**
+ * Checks if an error is a network error (connection failure, timeout, etc.).
+ *
+ * @param error - The error object
+ * @returns True if the error appears to be a network error
+ */
+declare function isNetworkError(error: Error): boolean;
+/**
+ * Default retry condition that retries on network errors.
+ * This is used when no retryCondition is provided in RetryConfig.
+ *
+ * @param error - The error that occurred
+ * @returns True if the error is a network error
+ */
+declare function defaultRetryCondition(error: Error): boolean;
+/**
+ * Helper function to create a retry condition that retries on specific HTTP status codes.
+ *
+ * @param statusCodes - Array of HTTP status codes to retry on
+ * @returns A retry condition function
+ *
+ * @example
+ * ```typescript
+ * retry: {
+ *   retryCondition: retryOnStatusCodes(500, 502, 503, 504, 429)
+ * }
+ * ```
+ */
+declare function retryOnStatusCodes(...statusCodes: number[]): (error: Error) => boolean;
+/**
+ * Helper function to create a retry condition that retries on network errors OR specific status codes.
+ *
+ * @param statusCodes - Array of HTTP status codes to retry on
+ * @returns A retry condition function
+ *
+ * @example
+ * ```typescript
+ * retry: {
+ *   retryCondition: retryOnNetworkOrStatusCodes(500, 502, 503, 504, 429)
+ * }
+ * ```
+ */
+declare function retryOnNetworkOrStatusCodes(...statusCodes: number[]): (error: Error, attempt: number) => boolean;
+
+/**
+ * Processes a ReadableStream progressively, calling the chunk handler for each chunk.
+ * Supports both text and binary streams.
+ *
+ * @template Chunk - The type of chunk data
+ * @param stream - The ReadableStream to process
+ * @param config - The chunk processing configuration
+ * @returns A promise that resolves when processing is complete, optionally with accumulated data
+ */
+declare function processStream<Chunk = string | Uint8Array>(stream: ReadableStream<Uint8Array>, config: ChunkProcessingConfig<Chunk>): Promise<Chunk | undefined>;
+/**
+ * Processes a text stream line by line (useful for NDJSON, CSV, or line-delimited data).
+ *
+ * @param stream - The ReadableStream to process
+ * @param config - The chunk processing configuration
+ * @returns A promise that resolves when processing is complete
+ */
+declare function processTextStreamLineByLine(stream: ReadableStream<Uint8Array>, config: ChunkProcessingConfig<string>): Promise<string | undefined>;
+/**
+ * Processes a Response body as a stream with chunk processing.
+ * Automatically detects if the response has a readable stream and processes it.
+ *
+ * @template Chunk - The type of chunk data
+ * @param response - The Response object
+ * @param config - The chunk processing configuration
+ * @returns A promise that resolves with the processed result or the original response
+ */
+declare function processResponseStream<Chunk = string | Uint8Array>(response: Response, config: ChunkProcessingConfig<Chunk>): Promise<Response | Chunk>;
+/**
+ * Checks if a value is a ReadableStream.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a ReadableStream
+ */
+declare function isReadableStream(value: unknown): value is ReadableStream<Uint8Array>;
+/**
+ * Checks if a Response has a readable body stream.
+ *
+ * @param response - The Response to check
+ * @returns True if the response has a readable body stream
+ */
+declare function hasReadableStream(response: Response): boolean;
+
+export { type BasePipelineStage, type ChunkHandler, type ChunkProcessingConfig, type ErrorHandler, type IRequestConfig, type IRequestConfigFactory, type PipelineManagerStage, type PipelineRequestStage, RequestAdapter, RequestChain, RequestFlow as RequestManager, type ResultHandler, type RetryConfig, SSRFError, type UrlValidationOptions, begin, RequestChain as default, defaultRetryCondition, getErrorStatus, hasReadableStream, isNetworkError, isReadableStream, processResponseStream, processStream, processTextStreamLineByLine, retryOnNetworkOrStatusCodes, retryOnStatusCodes, validateUrl };