/**
 * Middleware - AI SDK Wrapper
 *
 * Provides middleware utilities for caching, logging, and model wrapping.
 */
export interface Middleware {
    /** Middleware name */
    name: string;
    /** Transform request before sending */
    transformRequest?: (request: MiddlewareRequest) => Promise<MiddlewareRequest> | MiddlewareRequest;
    /** Transform response after receiving */
    transformResponse?: (response: MiddlewareResponse) => Promise<MiddlewareResponse> | MiddlewareResponse;
    /** Handle errors */
    onError?: (error: Error) => Promise<void> | void;
}
export interface MiddlewareRequest {
    model: string;
    prompt?: string;
    messages?: any[];
    system?: string;
    tools?: Record<string, any>;
    [key: string]: any;
}
export interface MiddlewareResponse {
    text?: string;
    object?: any;
    toolCalls?: any[];
    usage?: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
    };
    [key: string]: any;
}
export interface MiddlewareConfig {
    /** Enable caching */
    cache?: boolean;
    /** Cache TTL in seconds */
    cacheTTL?: number;
    /** Enable logging */
    logging?: boolean;
    /** Log level */
    logLevel?: 'debug' | 'info' | 'warn' | 'error';
    /** Custom middlewares */
    middlewares?: Middleware[];
}
/**
 * Create a caching middleware.
 *
 * @example
 * ```typescript
 * const cachingMiddleware = createCachingMiddleware({
 *   ttl: 3600, // 1 hour
 *   keyGenerator: (request) => `${request.model}:${request.prompt}`
 * });
 * ```
 */
export declare function createCachingMiddleware(options?: {
    ttl?: number;
    keyGenerator?: (request: MiddlewareRequest) => string;
    storage?: {
        get: (key: string) => Promise<any>;
        set: (key: string, value: any, ttl?: number) => Promise<void>;
    };
}): Middleware;
/**
 * Create a logging middleware.
 *
 * @example
 * ```typescript
 * const loggingMiddleware = createLoggingMiddleware({
 *   level: 'debug',
 *   onRequest: (request) => console.log('Request:', request),
 *   onResponse: (response) => console.log('Response:', response)
 * });
 * ```
 */
export declare function createLoggingMiddleware(options?: {
    level?: 'debug' | 'info' | 'warn' | 'error';
    onRequest?: (request: MiddlewareRequest) => void;
    onResponse?: (response: MiddlewareResponse) => void;
    onError?: (error: Error) => void;
}): Middleware;
/**
 * Wrap a model with middleware.
 *
 * @example
 * ```typescript
 * const wrappedModel = wrapModel(model, [
 *   createCachingMiddleware(),
 *   createLoggingMiddleware()
 * ]);
 * ```
 */
export declare function wrapModel(model: any, middlewares: Middleware[]): any;
/**
 * Apply middleware to a request/response cycle.
 */
export declare function applyMiddleware(middlewares: Middleware[], request: MiddlewareRequest, execute: (req: MiddlewareRequest) => Promise<MiddlewareResponse>): Promise<MiddlewareResponse>;
/**
 * Clear the response cache.
 */
export declare function clearCache(): void;
/**
 * Get cache statistics.
 */
export declare function getCacheStats(): {
    size: number;
    keys: string[];
};