import { C as CompressOptions, a as CompressResult, H as HeadroomClientOptions, b as HeadroomClientInterface, O as OpenAIMessage } from './types-BTrX7__W.js';
export { A as AssistantMessage, c as CompressContext, d as CompressEvent, e as CompressionHooks, f as ContentPart, I as ImageContentPart, S as SystemMessage, T as TextContentPart, g as ToolCall, h as ToolMessage, U as UserMessage, i as countTurns, j as extractToolCalls, k as extractUserQuery } from './types-BTrX7__W.js';

/**
 * Error hierarchy matching Python headroom.exceptions.
 */
declare class HeadroomError extends Error {
    details?: Record<string, any>;
    constructor(message: string, details?: Record<string, any>);
}
declare class HeadroomConnectionError extends HeadroomError {
    constructor(message: string, details?: Record<string, any>);
}
declare class HeadroomAuthError extends HeadroomError {
    constructor(message: string, details?: Record<string, any>);
}
declare class HeadroomCompressError extends HeadroomError {
    statusCode: number;
    errorType: string;
    constructor(statusCode: number, errorType: string, message: string, details?: Record<string, any>);
}
declare class ConfigurationError extends HeadroomError {
    constructor(message: string, details?: Record<string, any>);
}
declare class ProviderError extends HeadroomError {
    constructor(message: string, details?: Record<string, any>);
}
declare class StorageError extends HeadroomError {
    constructor(message: string, details?: Record<string, any>);
}
declare class TokenizationError extends HeadroomError {
    constructor(message: string, details?: Record<string, any>);
}
declare class CacheError extends HeadroomError {
    constructor(message: string, details?: Record<string, any>);
}
declare class ValidationError extends HeadroomError {
    constructor(message: string, details?: Record<string, any>);
}
declare class TransformError extends HeadroomError {
    constructor(message: string, details?: Record<string, any>);
}
/**
 * Map a proxy error response to the correct HeadroomError subclass.
 */
declare function mapProxyError(status: number, type: string, message: string): HeadroomError;

/**
 * Universal compress function with hooks support.
 * Accepts messages in any format: OpenAI, Anthropic, Vercel AI SDK, or Google Gemini.
 */

/**
 * Compress an array of messages using the Headroom proxy.
 *
 * Accepts messages in any format: OpenAI, Anthropic, Vercel AI SDK, or Google Gemini.
 * Detects the format automatically, compresses via the proxy, and returns
 * compressed messages in the same format as the input.
 */
declare function compress(messages: any[], options?: CompressOptions): Promise<CompressResult>;

/**
 * Configuration types matching Python headroom.config dataclasses.
 * All fields are optional — the proxy uses defaults for omitted values.
 */
type HeadroomMode = "audit" | "optimize" | "simulate";
type RelevanceTier = "bm25" | "embedding" | "hybrid";
type ContentType = "json" | "code" | "logs" | "text" | "html" | "diff" | "search" | "unknown";
type BlockKind = "system" | "user" | "assistant" | "tool_call" | "tool_result" | "rag" | "unknown";
interface ToolCrusherConfig {
    enabled?: boolean;
    minTokensToCrush?: number;
    maxArrayItems?: number;
    maxStringLength?: number;
    maxDepth?: number;
    preserveKeys?: string[];
    toolProfiles?: Record<string, Record<string, any>>;
}
interface CacheAlignerConfig {
    enabled?: boolean;
    useDynamicDetector?: boolean;
    detectionTiers?: ("regex" | "ner" | "semantic")[];
    extraDynamicLabels?: string[];
    entropyThreshold?: number;
    datePatterns?: string[];
    normalizeWhitespace?: boolean;
    collapseBlankLines?: boolean;
    dynamicTailSeparator?: string;
}
interface RollingWindowConfig {
    enabled?: boolean;
    keepSystem?: boolean;
    keepLastTurns?: number;
    outputBufferTokens?: number;
}
interface ScoringWeights {
    recency?: number;
    semanticSimilarity?: number;
    toinImportance?: number;
    errorIndicator?: number;
    forwardReference?: number;
    tokenDensity?: number;
}
interface IntelligentContextConfig {
    enabled?: boolean;
    keepSystem?: boolean;
    keepLastTurns?: number;
    outputBufferTokens?: number;
    useImportanceScoring?: boolean;
    scoringWeights?: ScoringWeights;
    recencyDecayRate?: number;
    toinIntegration?: boolean;
    toinConfidenceThreshold?: number;
    compressThreshold?: number;
    summarizationEnabled?: boolean;
    summarizationModel?: string | null;
    summaryMaxTokens?: number;
    summarizeThreshold?: number;
}
interface RelevanceScorerConfig {
    tier?: RelevanceTier;
    bm25K1?: number;
    bm25B?: number;
    embeddingModel?: string;
    hybridAlpha?: number;
    adaptiveAlpha?: boolean;
    relevanceThreshold?: number;
}
interface AnchorConfig {
    anchorBudgetPct?: number;
    minAnchorSlots?: number;
    maxAnchorSlots?: number;
    defaultFrontWeight?: number;
    defaultBackWeight?: number;
    defaultMiddleWeight?: number;
    useInformationDensity?: boolean;
    dedupIdenticalItems?: boolean;
}
interface SmartCrusherConfig {
    enabled?: boolean;
    minItemsToAnalyze?: number;
    minTokensToCrush?: number;
    varianceThreshold?: number;
    uniquenessThreshold?: number;
    similarityThreshold?: number;
    maxItemsAfterCrush?: number;
    preserveChangePoints?: boolean;
    useFeedbackHints?: boolean;
    toinConfidenceThreshold?: number;
    relevance?: RelevanceScorerConfig;
    anchor?: AnchorConfig;
    dedupIdenticalItems?: boolean;
    firstFraction?: number;
    lastFraction?: number;
}
interface CacheOptimizerConfig {
    enabled?: boolean;
    autoDetectProvider?: boolean;
    minCacheableTokens?: number;
    enableSemanticCache?: boolean;
    semanticCacheSimilarity?: number;
    semanticCacheMaxEntries?: number;
    semanticCacheTtlSeconds?: number;
}
interface CCRConfig {
    enabled?: boolean;
    storeMaxEntries?: number;
    storeTtlSeconds?: number;
    injectRetrievalMarker?: boolean;
    feedbackEnabled?: boolean;
    minItemsToCache?: number;
    injectTool?: boolean;
    injectSystemInstructions?: boolean;
    markerTemplate?: string;
}
interface PrefixFreezeConfig {
    enabled?: boolean;
    minCachedTokens?: number;
    sessionTtlSeconds?: number;
    forceCompressThreshold?: number;
}
interface ReadLifecycleConfig {
    enabled?: boolean;
    compressStale?: boolean;
    compressSuperseded?: boolean;
    minSizeBytes?: number;
}
interface CompressionProfile {
    bias?: number;
    minK?: number;
    maxK?: number | null;
}
interface HeadroomConfig {
    storeUrl?: string;
    defaultMode?: HeadroomMode;
    modelContextLimits?: Record<string, number>;
    toolCrusher?: ToolCrusherConfig;
    smartCrusher?: SmartCrusherConfig;
    cacheAligner?: CacheAlignerConfig;
    rollingWindow?: RollingWindowConfig;
    cacheOptimizer?: CacheOptimizerConfig;
    ccr?: CCRConfig;
    prefixFreeze?: PrefixFreezeConfig;
    contentRouterEnabled?: boolean;
    intelligentContext?: IntelligentContextConfig;
    generateDiffArtifact?: boolean;
}

/**
 * Data models matching Python headroom.config result/metrics dataclasses.
 */

interface WasteSignals {
    jsonBloatTokens: number;
    htmlNoiseTokens: number;
    base64Tokens: number;
    whitespaceTokens: number;
    dynamicDateTokens: number;
    repetitionTokens: number;
    total: number;
}
interface CachePrefixMetrics {
    stablePrefixBytes: number;
    stablePrefixTokensEst: number;
    stablePrefixHash: string;
    prefixChanged: boolean;
    previousHash?: string | null;
}
interface TransformDiff {
    transformName: string;
    tokensBefore: number;
    tokensAfter: number;
    tokensSaved: number;
    itemsRemoved: number;
    itemsKept: number;
    details: string;
    durationMs: number;
}
interface DiffArtifact {
    requestId: string;
    originalTokens: number;
    optimizedTokens: number;
    totalTokensSaved: number;
    transforms: TransformDiff[];
}
interface SimulationResult {
    tokensBefore: number;
    tokensAfter: number;
    tokensSaved: number;
    transforms: string[];
    estimatedSavings: string;
    messagesOptimized: any[];
    blockBreakdown: Record<string, number>;
    wasteSignals: Record<string, number>;
    stablePrefixHash: string;
    cacheAlignmentScore: number;
}
interface RequestMetrics {
    requestId: string;
    timestamp: string;
    model: string;
    stream: boolean;
    mode: string;
    tokensInputBefore: number;
    tokensInputAfter: number;
    tokensOutput?: number | null;
    blockBreakdown: Record<string, number>;
    wasteSignals: Record<string, number>;
    stablePrefixHash: string;
    cacheAlignmentScore: number;
    cachedTokens?: number | null;
    cacheOptimizerUsed?: string | null;
    cacheOptimizerStrategy?: string | null;
    cacheableTokens: number;
    breakpointsInserted: number;
    estimatedCacheHit: boolean;
    estimatedSavingsPercent: number;
    semanticCacheHit: boolean;
    transformsApplied: string[];
    toolUnitsDropped: number;
    turnsDropped: number;
    messagesHash: string;
    error?: string | null;
}
interface Block {
    kind: BlockKind;
    text: string;
    tokensEst: number;
    contentHash: string;
    sourceIndex: number;
    flags: Record<string, any>;
}
interface SessionStats {
    totalRequests: number;
    totalTokensBefore: number;
    totalTokensAfter: number;
    totalTokensSaved: number;
    averageCompressionRatio: number;
    cacheHits: number;
    byMode: Record<string, {
        requests: number;
        tokensSaved: number;
    }>;
}
interface ValidationResult {
    valid: boolean;
    provider: string;
    errors: string[];
    warnings: string[];
    config: Record<string, any>;
}
interface MetricsSummary {
    totalRequests: number;
    totalTokensBefore: number;
    totalTokensAfter: number;
    totalTokensSaved: number;
    averageCompressionRatio: number;
    models: Record<string, number>;
    modes: Record<string, number>;
    errorCount: number;
}
interface HealthStatus {
    status: "healthy" | "unhealthy";
    version: string;
    config: {
        optimize: boolean;
        cache: boolean;
        rateLimit: boolean;
    };
}
interface ProxyStats {
    requests: {
        total: number;
        cached: number;
        rateLimited: number;
        failed: number;
        byProvider: Record<string, number>;
        byModel: Record<string, number>;
    };
    tokens: {
        input: number;
        output: number;
        saved: number;
        cliTokensAvoided: number;
        totalBeforeCompression: number;
        savingsPercent: number;
    };
    latency: {
        averageMs: number;
        minMs: number;
        maxMs: number;
    };
    overhead: {
        averageMs: number;
        minMs: number;
        maxMs: number;
    };
    pipelineTiming: Record<string, {
        averageMs: number;
        maxMs: number;
        count: number;
    }>;
    wasteSignals: Record<string, number>;
    compression: {
        ccrEntries: number;
        ccrMaxEntries: number;
        originalTokensCached: number;
        compressedTokensCached: number;
        ccrRetrievals: number;
    };
    cost: Record<string, any>;
    feedbackLoop: {
        toolsTracked: number;
        totalCompressions: number;
        totalRetrievals: number;
        globalRetrievalRate: number;
    };
}
interface MemoryUsage {
    processMemory: {
        rss: number;
        vms: number;
        percent: number;
    };
    components: Record<string, {
        memoryMb: number;
        budgetMb: number;
    }>;
    totalTrackedMb: number;
    targetBudgetMb: number;
}
interface RetrieveResult {
    hash: string;
    originalContent: string;
    originalTokens: number;
    originalItemCount: number;
    compressedItemCount: number;
    toolName: string;
    retrievalCount: number;
}
interface RetrieveSearchResult {
    hash: string;
    query: string;
    results: any[];
    count: number;
}
interface CCRStats {
    store: {
        entries: number;
        maxEntries: number;
        originalTokensCached: number;
        compressedTokensCached: number;
        retrievals: number;
    };
    recentRetrievals: Array<{
        hash: string;
        query: string | null;
        itemsRetrieved: number;
        totalItems: number;
        toolName: string;
        retrievalType: string;
    }>;
}
interface TelemetryStats {
    enabled: boolean;
    totalCompressions: number;
    totalRetrievals: number;
    globalRetrievalRate: number;
    toolSignaturesTracked: number;
    avgCompressionRatio: number;
    avgTokenReduction: number;
}
interface ToolHints {
    toolName: string;
    hints: {
        maxItems: number;
        minItems: number;
        suggestedItems: any[];
        aggressiveness: number;
        skipCompression: boolean;
        preserveFields: string[];
        reason: string;
    };
    pattern: {
        totalCompressions: number;
        totalRetrievals: number;
        retrievalRate: number;
        fullRetrievalRate: number;
        searchRate: number;
        commonQueries: string[];
        queriedFields: string[];
    };
}
interface TOINStats {
    enabled: boolean;
    patternsTracked: number;
    totalCompressions: number;
    totalRetrievals: number;
    globalRetrievalRate: number;
    patternsWithRecommendations: number;
}
interface TOINPattern {
    hash: string;
    compressions: number;
    retrievals: number;
    retrievalRate: string;
    confidence: number;
    skipRecommended: boolean;
    optimalMaxItems: number;
}
interface MetricsQuery {
    startTime?: Date;
    endTime?: Date;
    model?: string;
    mode?: string;
    limit?: number;
}
interface SummaryQuery {
    startTime?: Date;
    endTime?: Date;
}
interface StatsHistoryQuery {
    format?: "json" | "csv";
    series?: "history" | "hourly" | "daily" | "weekly" | "monthly";
}

/**
 * HeadroomClient — HTTP client for the Headroom compression proxy.
 *
 * Supports:
 * - compress() — direct compression via /v1/compress
 * - chat.completions.create() — OpenAI-style passthrough via /v1/chat/completions
 * - messages.create() — Anthropic-style passthrough via /v1/messages
 * - Metrics, health, CCR retrieve, telemetry, feedback, TOIN
 */

interface HeadroomParams {
    headroomMode?: HeadroomMode;
    headroomCachePrefixTokens?: number;
    headroomOutputBufferTokens?: number;
    headroomKeepTurns?: number;
    headroomToolProfiles?: Record<string, Record<string, any>>;
}
declare class ChatCompletions {
    private client;
    constructor(client: HeadroomClient);
    /**
     * Create a chat completion with automatic compression.
     * Routes through proxy's POST /v1/chat/completions.
     */
    create(params: {
        model: string;
        messages: OpenAIMessage[];
        stream?: boolean;
        [key: string]: any;
    } & HeadroomParams): Promise<any>;
    /**
     * Simulate compression without calling the LLM.
     */
    simulate(params: {
        model: string;
        messages: OpenAIMessage[];
    } & HeadroomParams): Promise<SimulationResult>;
}
declare class Messages {
    private client;
    constructor(client: HeadroomClient);
    /**
     * Create a message with automatic compression.
     * Routes through proxy's POST /v1/messages (Anthropic).
     */
    create(params: {
        model: string;
        messages: any[];
        max_tokens?: number;
        system?: string | any[];
        stream?: boolean;
        [key: string]: any;
    } & HeadroomParams): Promise<any>;
    /**
     * Stream a message with automatic compression.
     */
    stream(params: {
        model: string;
        messages: any[];
        max_tokens?: number;
        system?: string | any[];
        [key: string]: any;
    } & HeadroomParams): Promise<AsyncGenerator<any>>;
    /**
     * Simulate compression without calling the LLM.
     */
    simulate(params: {
        model: string;
        messages: any[];
    } & HeadroomParams): Promise<SimulationResult>;
}
interface ExtendedClientOptions extends HeadroomClientOptions {
    providerApiKey?: string;
    defaultMode?: HeadroomMode;
    config?: HeadroomConfig;
}
declare class HeadroomClient implements HeadroomClientInterface {
    private baseUrl;
    private apiKey;
    private timeout;
    private fallback;
    private retries;
    private config;
    private stack;
    /** @internal */ providerApiKey: string | undefined;
    /** OpenAI-style chat completions API. */
    readonly chat: {
        completions: ChatCompletions;
    };
    /** Anthropic-style messages API. */
    readonly messages: Messages;
    constructor(options?: ExtendedClientOptions);
    compress(messages: OpenAIMessage[], options?: {
        model?: string;
        tokenBudget?: number;
    }): Promise<CompressResult>;
    /**
     * Raw compress call — sends body directly to /v1/compress.
     * Used by simulate() and other advanced features.
     * @internal
     */
    compressRaw(body: Record<string, any>): Promise<any>;
    /** Check if the proxy is running and healthy. */
    health(): Promise<HealthStatus>;
    /** Get comprehensive proxy statistics. */
    proxyStats(): Promise<ProxyStats>;
    /** Get Prometheus-format metrics. */
    prometheusMetrics(): Promise<string>;
    /** Get historical stats. */
    statsHistory(query?: StatsHistoryQuery): Promise<any>;
    /** Get proxy memory usage. */
    memoryUsage(): Promise<MemoryUsage>;
    /** Clear the response cache. */
    clearCache(): Promise<{
        status: string;
    }>;
    /** Get request metrics from the proxy. */
    getMetrics(query?: MetricsQuery): Promise<RequestMetrics[]>;
    /** Get aggregated metrics summary. */
    getSummary(query?: SummaryQuery): Promise<MetricsSummary>;
    /** Get in-memory session stats. */
    getStats(): Promise<SessionStats>;
    /** Validate proxy configuration. */
    validateSetup(): Promise<ValidationResult>;
    /** Retrieve original content from the CCR compression store. */
    retrieve(hash: string, options?: {
        query?: string;
    }): Promise<RetrieveResult | RetrieveSearchResult>;
    /** Get CCR store statistics. */
    getCCRStats(): Promise<CCRStats>;
    /** Handle an LLM tool call for headroom_retrieve. */
    handleToolCall(request: {
        toolCall: any;
        provider?: "anthropic" | "openai";
    }): Promise<any>;
    readonly telemetry: {
        getStats: () => Promise<TelemetryStats>;
        export: () => Promise<any>;
        import: (data: any) => Promise<{
            status: string;
        }>;
        getTools: () => Promise<any>;
        getTool: (signatureHash: string) => Promise<any>;
    };
    readonly feedback: {
        getStats: () => Promise<any>;
        getHints: (toolName: string) => Promise<ToolHints>;
    };
    readonly toin: {
        getStats: () => Promise<TOINStats>;
        getPatterns: (limit?: number) => Promise<TOINPattern[]>;
        getPattern: (hashPrefix: string) => Promise<any>;
    };
    /** Close the client (no-op for HTTP client, included for API parity). */
    close(): void;
    /**
     * Raw fetch with proxy base URL, auth, and timeout.
     * @internal
     */
    rawFetch(path: string, options: {
        method: string;
        headers?: Record<string, string>;
        body?: any;
        stream?: boolean;
    }): Promise<Response>;
    /** @internal */
    private _fetch;
    private _doCompress;
}

/**
 * Simulation API — dry-run compression to see what would happen.
 * Matches Python client.simulate() behavior.
 */

interface SimulateOptions extends HeadroomClientOptions {
    model?: string;
    config?: HeadroomConfig;
    client?: HeadroomClient;
}
/**
 * Simulate compression without calling the LLM.
 * Shows what compression would do: token savings, transforms, waste signals.
 *
 * @example
 * ```typescript
 * const sim = await simulate(messages, { model: 'gpt-4o' });
 * console.log(`Would save ${sim.tokensSaved} tokens (${sim.estimatedSavings})`);
 * console.log('Transforms:', sim.transforms);
 * ```
 */
declare function simulate(messages: any[], options?: SimulateOptions): Promise<SimulationResult>;

/**
 * Universal message format detection and conversion.
 *
 * Supports 4 formats:
 *   - OpenAI:   { role, content, tool_calls?, tool_call_id? }
 *   - Anthropic: { role, content (string | ContentBlock[]) } with tool_use/tool_result blocks
 *   - Vercel AI SDK: { role, content (string | Part[]) } with tool-call/tool-result parts
 *   - Google Gemini: { role, parts[] } with functionCall/functionResponse
 *
 * Detection is structural (unique keys/values per format), not heuristic.
 * Conversion always targets OpenAI format (the proxy's lingua franca).
 */

type MessageFormat = "openai" | "anthropic" | "vercel" | "gemini";
/**
 * Detect which format an array of messages is in.
 *
 * Uses structural markers unique to each format:
 *   - Gemini: messages have `parts` field (not `content`)
 *   - Vercel: content parts use hyphenated types: `tool-call`, `tool-result`
 *   - Anthropic: content blocks use underscored types: `tool_use`, `tool_result`
 *   - OpenAI: assistant messages have `tool_calls` field; tool messages have `tool_call_id`
 */
declare function detectFormat(messages: any[]): MessageFormat;
declare function toOpenAI(messages: any[]): OpenAIMessage[];
declare function fromOpenAI(messages: OpenAIMessage[], targetFormat: MessageFormat): any[];

/**
 * Case conversion utilities for proxy communication.
 * Proxy uses snake_case (Python), SDK uses camelCase (TypeScript).
 */
declare function snakeToCamel(str: string): string;
declare function camelToSnake(str: string): string;
declare function deepCamelCase<T = any>(obj: any): T;
declare function deepSnakeCase(obj: any): any;

/**
 * SSE (Server-Sent Events) stream parser for proxy streaming responses.
 */
/**
 * Parse an SSE response body into an async generator of parsed JSON events.
 */
declare function parseSSE<T = any>(response: Response): AsyncGenerator<T>;
/**
 * Collect all chunks from an async iterable into an array.
 */
declare function collectStream<T>(stream: AsyncIterable<T>): Promise<T[]>;

/**
 * SharedContext — compressed inter-agent context sharing.
 * Matches Python headroom.shared_context.SharedContext.
 */

interface ContextEntry {
    key: string;
    original: string;
    compressed: string;
    originalTokens: number;
    compressedTokens: number;
    agent: string | null;
    timestamp: number;
    transforms: string[];
    savingsPercent: number;
}
interface SharedContextStats {
    entries: number;
    totalOriginalTokens: number;
    totalCompressedTokens: number;
    totalTokensSaved: number;
    savingsPercent: number;
}
interface SharedContextOptions extends HeadroomClientOptions {
    model?: string;
    ttl?: number;
    maxEntries?: number;
}
declare class SharedContext {
    private entries;
    private client;
    private model;
    private ttl;
    private maxEntries;
    constructor(options?: SharedContextOptions);
    /**
     * Store content with compression.
     */
    put(key: string, content: string, options?: {
        agent?: string;
    }): Promise<ContextEntry>;
    /**
     * Get content by key. Returns compressed by default, full original if full=true.
     */
    get(key: string, options?: {
        full?: boolean;
    }): string | null;
    /**
     * Get full entry metadata.
     */
    getEntry(key: string): ContextEntry | null;
    /**
     * List all stored keys (excluding expired).
     */
    keys(): string[];
    /**
     * Get aggregated statistics.
     */
    stats(): SharedContextStats;
    /**
     * Clear all entries.
     */
    clear(): void;
    private evictExpired;
    private evictIfFull;
}

/**
 * Canonical filesystem contract for Headroom — parity shell for the npm SDK.
 *
 * The TypeScript SDK is an HTTP client today and does not touch the
 * filesystem directly. This module mirrors `headroom/paths.py` so that
 * future local features (e.g. cache/log co-location with the Python
 * proxy) land on the same contract.
 *
 * Two canonical roots:
 *   - HEADROOM_CONFIG_DIR     — read-mostly configuration
 *                               (default: ~/.headroom/config)
 *   - HEADROOM_WORKSPACE_DIR  — read-write state
 *                               (default: ~/.headroom)
 *
 * Precedence for every per-resource helper is:
 *   explicit argument > per-resource env var > derived from canonical
 *   root > default.
 *
 * Browser behavior: when `process` is not available (typeof process ===
 * "undefined"), all helpers return the empty string. Consumers running
 * in a browser should not call these helpers; they exist here so the
 * shape of the API matches Python's `headroom.paths` module.
 */
declare const HEADROOM_CONFIG_DIR_ENV = "HEADROOM_CONFIG_DIR";
declare const HEADROOM_WORKSPACE_DIR_ENV = "HEADROOM_WORKSPACE_DIR";
declare const HEADROOM_SAVINGS_PATH_ENV = "HEADROOM_SAVINGS_PATH";
declare const HEADROOM_TOIN_PATH_ENV = "HEADROOM_TOIN_PATH";
declare const HEADROOM_SUBSCRIPTION_STATE_PATH_ENV = "HEADROOM_SUBSCRIPTION_STATE_PATH";
declare function workspaceDir(): string;
declare function configDir(): string;
declare function savingsPath(explicit?: string): string;
declare function toinPath(explicit?: string): string;
declare function subscriptionStatePath(explicit?: string): string;
declare function memoryDbPath(): string;
declare function nativeMemoryDir(): string;
declare function licenseCachePath(): string;
declare function sessionStatsPath(): string;
declare function syncStatePath(): string;
declare function bridgeStatePath(): string;
declare function logDir(): string;
declare function proxyLogPath(): string;
declare function debug400Dir(): string;
declare function binDir(): string;
declare function rtkPath(): string;
declare function deployRoot(): string;
declare function beaconLockPath(port: number): string;
declare function modelsConfigPath(): string;
declare function pluginConfigDir(pluginName: string): string;
declare function pluginWorkspaceDir(pluginName: string): string;

export { type AnchorConfig, type Block, type BlockKind, type CCRConfig, type CCRStats, type CacheAlignerConfig, CacheError, type CacheOptimizerConfig, type CachePrefixMetrics, CompressOptions, CompressResult, type CompressionProfile, ConfigurationError, type ContentType, type ContextEntry, type DiffArtifact, type ExtendedClientOptions, HEADROOM_CONFIG_DIR_ENV, HEADROOM_SAVINGS_PATH_ENV, HEADROOM_SUBSCRIPTION_STATE_PATH_ENV, HEADROOM_TOIN_PATH_ENV, HEADROOM_WORKSPACE_DIR_ENV, HeadroomAuthError, HeadroomClient, HeadroomClientInterface, HeadroomClientOptions, HeadroomCompressError, type HeadroomConfig, HeadroomConnectionError, HeadroomError, type HeadroomMode, type HeadroomParams, type HealthStatus, type IntelligentContextConfig, type MemoryUsage, type MessageFormat, type MetricsQuery, type MetricsSummary, OpenAIMessage, type PrefixFreezeConfig, ProviderError, type ProxyStats, type ReadLifecycleConfig, type RelevanceScorerConfig, type RelevanceTier, type RequestMetrics, type RetrieveResult, type RetrieveSearchResult, type RollingWindowConfig, type ScoringWeights, type SessionStats, SharedContext, type SharedContextOptions, type SharedContextStats, type SimulateOptions, type SimulationResult, type SmartCrusherConfig, type StatsHistoryQuery, StorageError, type SummaryQuery, type TOINPattern, type TOINStats, type TelemetryStats, TokenizationError, type ToolCrusherConfig, type ToolHints, type TransformDiff, TransformError, ValidationError, type ValidationResult, type WasteSignals, beaconLockPath, binDir, bridgeStatePath, camelToSnake, collectStream, compress, configDir, debug400Dir, deepCamelCase, deepSnakeCase, deployRoot, detectFormat, fromOpenAI, licenseCachePath, logDir, mapProxyError, memoryDbPath, modelsConfigPath, nativeMemoryDir, parseSSE, pluginConfigDir, pluginWorkspaceDir, proxyLogPath, rtkPath, savingsPath, sessionStatsPath, simulate, snakeToCamel, subscriptionStatePath, syncStatePath, toOpenAI, toinPath, workspaceDir };