/**
 * Response Adapter for Edge Function envelope format
 * Handles the transition between direct API responses and Edge Function wrapped responses
 */
import { EdgeFunctionResponse } from "../core/types.js";
import { ApiResponse } from "./http-client.js";
export interface UsageInfo {
    tokens_used: number;
    cost_usd: number;
    cached: boolean;
}
export interface TierInfo {
    tier: string;
    usage_remaining: number;
}
export interface UnwrappedResponse<T> {
    data?: T;
    error?: {
        message: string;
        code?: string;
    };
    usage?: UsageInfo;
    tier_info?: TierInfo;
    status: number;
}
/**
 * Adapts Edge Function envelope response to SDK internal format
 * Edge Functions return: { success, data, error, usage, tier_info }
 * SDK expects: { data, error, status }
 */
export declare function adaptEdgeFunctionResponse<T>(httpResponse: ApiResponse<EdgeFunctionResponse<T>>): UnwrappedResponse<T>;
/**
 * Checks if a response appears to be an Edge Function envelope
 */
export declare function isEdgeFunctionEnvelope(data: unknown): data is EdgeFunctionResponse<unknown>;
/**
 * Smart adapter that detects response format and adapts accordingly
 * Supports both direct API responses and Edge Function envelopes
 */
export declare function adaptResponse<T>(httpResponse: ApiResponse<T | EdgeFunctionResponse<T>>): UnwrappedResponse<T>;
/**
 * Cache entry for offline fallback support
 */
export interface CacheEntry<T> {
    data: T;
    timestamp: number;
    endpoint: string;
    params?: Record<string, unknown>;
}
/**
 * Simple in-memory cache for offline fallback
 */
export declare class ResponseCache {
    private cache;
    private ttl;
    constructor(ttlMs?: number);
    private generateKey;
    set<T>(endpoint: string, data: T, params?: Record<string, unknown>): void;
    get<T>(endpoint: string, params?: Record<string, unknown>): T | null;
    clear(): void;
    /**
     * Clean up expired entries
     */
    cleanup(): void;
}