import { ApiResponse } from './types';
export { normalizeError, isApiError, type ErrorNormalizationConfig } from './error-normalizer';
export { extractCacheHints, buildCacheInfo, generateCacheControl, type CacheHints, } from './cache-hints';
export { streamResponse } from './stream-handler';
export { extractPagination, createPaginatedResponse, mergePaginatedResponses, type PaginationConfig, } from './pagination-helpers';
/**
 * Response parser configuration
 */
export interface ResponseParserConfig<T> {
    /** Schema validator (e.g., Zod schema) */
    schema?: {
        parse: (data: unknown) => T;
    };
    /** Transform function applied after parsing */
    transform?: (data: T) => T;
    /** Default value if response is empty */
    defaultValue?: T;
    /** Whether to throw on validation errors */
    throwOnValidationError?: boolean;
    /** Custom error message for validation failures */
    validationErrorMessage?: string;
}
/**
 * Parse and optionally validate an API response
 *
 * @typeParam T - Expected response data type
 * @param response - Raw API response
 * @param config - Parser configuration
 * @returns Parsed and validated data
 *
 * @example
 * ```typescript
 * import { z } from 'zod';
 *
 * const userSchema = z.object({
 *   id: z.string(),
 *   name: z.string(),
 *   email: z.string().email(),
 * });
 *
 * const user = parseResponse<User>(response, {
 *   schema: userSchema,
 *   transform: (u) => ({ ...u, displayName: u.name.toUpperCase() }),
 * });
 * ```
 */
export declare function parseResponse<T>(response: ApiResponse, config?: ResponseParserConfig<T>): T;
/**
 * Create a response parser for a specific type
 *
 * @example
 * ```typescript
 * const parseUser = createResponseParser<User>({
 *   schema: userSchema,
 * });
 *
 * const user = parseUser(response);
 * ```
 */
export declare function createResponseParser<T>(config: ResponseParserConfig<T>): (response: ApiResponse) => T;
/**
 * Response transformer function type
 */
export type ResponseTransformer<TInput, TOutput> = (data: TInput) => TOutput;
/**
 * Create a transformation pipeline for responses
 *
 * @example
 * ```typescript
 * const pipeline = createTransformPipeline(
 *   (data: ApiUser[]) => data.map(normalizeUser),
 *   (users) => users.filter(u => u.active),
 *   (users) => users.sort((a, b) => a.name.localeCompare(b.name)),
 * );
 *
 * const users = pipeline(response.data);
 * ```
 */
export declare function createTransformPipeline<T, U = T>(fn?: ResponseTransformer<T, U>): {
    pipe: <V>(nextFn: ResponseTransformer<U, V>) => {
        pipe: <W>(nextFn: ResponseTransformer<V, W>) => ReturnType<typeof createTransformPipeline<T, W>>;
        execute: (data: T) => V;
    };
    execute: (data: T) => U;
};
/**
 * Common transformers
 */
export declare const transformers: {
    /**
     * Normalize dates in response (ISO string to Date)
     */
    normalizeDates: <T extends Record<string, unknown>>(fields: string[]) => ResponseTransformer<T, T>;
    /**
     * Rename fields in response
     */
    renameFields: <T extends Record<string, unknown>>(mapping: Record<string, string>) => ResponseTransformer<T, T>;
    /**
     * Pick specific fields from response
     */
    pickFields: <T extends Record<string, unknown>, K extends keyof T>(fields: K[]) => ResponseTransformer<T, Pick<T, K>>;
    /**
     * Omit specific fields from response
     */
    omitFields: <T extends Record<string, unknown>, K extends keyof T>(fields: K[]) => ResponseTransformer<T, Omit<T, K>>;
    /**
     * Apply default values to missing fields
     */
    withDefaults: <T extends Record<string, unknown>>(defaults: Partial<T>) => ResponseTransformer<T, T>;
};