/**
 * ThinkHive SDK v4.1.0
 *
 * Run-centric AI agent observability platform with:
 * - Facts vs Inferences (claims API)
 * - Deterministic ticket linking (7 methods)
 * - Customer context snapshots (time-series)
 * - Calibrated predictions (Brier scores)
 * - Configurable ROI calculation engine
 *
 * @version 4.1.0
 * @license MIT
 */
import { isInitialized, SDK_VERSION, DEFAULT_ENDPOINT } from './core/config';
import { ThinkHiveError, ThinkHiveApiError, ThinkHiveValidationError, PermissionDeniedError, AgentScopeError, RateLimitError, IpWhitelistError } from './core/client';
import { runs, createRunWithContext, toOpenAIMessages, fromOpenAIMessages } from './api/runs';
import { claims, isFact, isInference, isComputed, getHighConfidenceClaims, groupClaimsByType, groupClaimsByCategory } from './api/claims';
import { calibration, calculateBrierScore, calculateECE, isWellCalibrated, getCalibrationQuality } from './api/calibration';
import { humanReview } from './api/human-review';
import { nondeterminism, calculatePassAtK, calculatePassToK, requiredPassRateForPassAtK, isReliableEvaluation, getReliabilityRecommendation } from './api/nondeterminism';
import { evalHealth, hasHealthIssue, getSeverityLevel as getHealthSeverityLevel, isSaturated, getSaturationRecommendation } from './api/eval-health';
import { deterministicGraders, createRegexRule, createContainsRule, createLengthRule, createJsonSchemaRule, allRulesPassed, getFailedRules, calculateAverageScore } from './api/deterministic-graders';
import { conversationEval, aggregateWorst, aggregateAverage, aggregateWeighted, aggregateFinalTurn, aggregateMajority, getAggregator, getProblematicTurns, analyzeConversationTrend } from './api/conversation-eval';
import { transcriptPatterns, isHighRisk, getMatchesByCategory, getCriticalInsights, hasPiiExposure, hasFrustrationSignals, hasEscalationRequest, getCategoryDistribution, getRecommendations, needsAttention, sortMatchesBySeverity } from './api/transcript-patterns';
import { agents } from './api/agents';
import { evalRuns } from './api/eval-runs';
import { signals } from './api/signals';
import { notifications } from './api/notifications';
import { documents } from './api/documents';
import { shadowTests } from './api/shadow-tests';
import { sessions } from './api/sessions';
import { drift, hasDrift, getDriftSeverity } from './api/drift';
import { llmCosts, formatCost as formatLLMCost } from './api/llm-costs';
import { guardrails } from './guardrails';
import { apiKeys, hasPermission, isExpired as isApiKeyExpired, isValid as isApiKeyValid, getTimeUntilExpiry, canAccessAgent } from './api/apiKeys';
import { roiAnalytics, calculateRevenueAtRisk, calculateAutomationSavings, formatCurrency, getROIQuality } from './api/roi-analytics';
import { businessMetrics, isMetricReady, needsMoreTraces, awaitingExternalData, isMetricStale, getStatusMessage, getTraceProgress, formatMetricValue, getTrendEmoji } from './api/business-metrics';
import { qualityMetrics, passesQualityThreshold, isHallucinationRiskAcceptable, getQualityRecommendations, formatQualityScore, getGradeColor } from './api/quality-metrics';
import { linking, generateZendeskMarker, parseZendeskMarker, hasZendeskMarker, removeZendeskMarker, linkRunToTicket, linkRunToZendeskTicket, getBestLinkMethod, LINK_METHOD_CONFIDENCE } from './integrations/ticket-linking';
import { customerContext, captureCustomerContext, getContextAsOf, toContextSnapshot, calculateArrChange, calculateHealthTrend } from './integrations/customer-context';
export type { InitOptions, Framework, RunOptions, RunOutcome, ConversationMessage, CustomerContextSnapshot, TicketLinkingOptions, LinkMethod, TraceOptions, TraceCustomFlag, SpanData, BusinessContext, Claim, ClaimType, ClaimCategory, ConfidenceCalibration, EvidenceReference, AnalysisResult, CalibrationStatus, CalibrationBucket, PredictionType, RoiConfig, RoiSummary, ExplainabilityResult, ApiResponse, PaginatedResponse, RunResponse, } from './core/types';
export type { HumanReviewStatus, HumanReviewType, HumanReviewQueueItem, CalibrationSet, ReviewerCalibration, QueueStats, } from './api/human-review';
export type { NondeterminismRunType, NondeterminismRunStatus, NondeterminismRun, NondeterminismSample, TraceAnalysis, CriterionAnalysis, RunSummary, } from './api/nondeterminism';
export type { SaturationType, HealthStatus, RegressionSeverity, EvalHealthSnapshot, EvalRegression, HealthReport, } from './api/eval-health';
export type { RuleType, DeterministicEvalResult, RuleResult, RuleTypeInfo, RuleTemplate, } from './api/deterministic-graders';
export type { AggregateMethod, SessionTrace, TurnEvaluation, ConversationEvalResult, AggregationMethodInfo, } from './api/conversation-eval';
export type { PatternCategory, PatternOutcome, PatternSeverity, PatternMatch, PatternInsight, AnalysisResult as PatternAnalysisResult, PatternCategoryInfo, BuiltInPattern, } from './api/transcript-patterns';
export type { ApiKeyPermissions, ScopeType, Environment, CreateApiKeyOptions, ApiKey, CreateApiKeyResult, } from './api/apiKeys';
export type { IndustryConfig, CustomIndustryConfig, ROIMetrics, BusinessImpact, ROISummary, TrendDataPoint, Correlation, PatternCluster, CorrelationAnalysis, } from './api/roi-analytics';
export type { RetrievedContext, GroundTruthContext, GroundedSpan, UngroundedSpan, CitationMap, RAGEvaluation, RAGEvidence, HallucinationInstance, HallucinationReport, GroundednessResult, BatchEvaluationResult, BatchEvaluationSummary, } from './api/quality-metrics';
export type { MetricTrend, MetricStatus, CurrentMetricResponse, MetricHistoryPoint, MetricHistorySummary, MetricHistoryResponse, RecordMetricOptions, RecordMetricResponse, } from './api/business-metrics';
export type { Agent, CreateAgentOptions, UpdateAgentOptions, AgentConfig, UpdateAgentConfigOptions, DeleteAgentOptions, CascadeImpact, } from './api/agents';
export type { CreateEvalRunOptions, GetEvalRunResultsOptions, ListEvalRunsOptions, EstimateCostOptions, GetTraceResultsOptions, EvalRun, EvalResult, EvalCostEstimate, } from './api/eval-runs';
export type { DetectionConfig, CreateSignalOptions, UpdateSignalOptions, ListSignalsOptions, SignalStatsOptions, SignalTrendsOptions, SignalTracesOptions, SignalEventsOptions, Signal, SignalStats, SignalTrendPoint, SignalEvent, } from './api/signals';
export type { NotificationRule, CreateNotificationRuleData, UpdateNotificationRuleData, Notification, } from './api/notifications';
export type { Document, DocumentUploadResponse, } from './api/documents';
export type { CreateShadowTestData, UpdateShadowTestData, ShadowTest, } from './api/shadow-tests';
export type { ListSessionsOptions, Session, SessionTrace as SessionTraceRecord, } from './api/sessions';
export type { DetectDriftOptions, DriftReport, DriftDimension, DetectAllResult, } from './api/drift';
export type { CostQueryOptions, CostSummary, CostBreakdownItem, AgentCostBreakdown, CostSavings, OptimizationEntry, OptimizationStats, OptimizationRecommendation, } from './api/llm-costs';
/**
 * Initialize ThinkHive SDK v3
 *
 * @example
 * ```typescript
 * import { init } from '@thinkhive/sdk';
 *
 * init({
 *   apiKey: 'th_your_api_key',
 *   serviceName: 'my-ai-agent',
 *   autoInstrument: true,
 *   frameworks: ['langchain', 'openai'],
 * });
 * ```
 */
export declare function init(options?: import('./core/types').InitOptions): void;
/**
 * Get the global tracer
 */
export declare function getTracer(): import("@opentelemetry/api").Tracer;
/**
 * Shutdown the SDK and flush pending spans
 */
export declare function shutdown(): Promise<void>;
/**
 * Trace an LLM call
 */
export declare function traceLLM<T>(options: {
    name: string;
    modelName?: string;
    provider?: string;
    input?: unknown;
}, fn: () => Promise<T>): Promise<T>;
/**
 * Trace a retrieval operation
 */
export declare function traceRetrieval<T>(options: {
    name: string;
    query?: string;
    topK?: number;
}, fn: () => Promise<T>): Promise<T>;
/**
 * Trace a tool call
 */
export declare function traceTool<T>(options: {
    name: string;
    toolName?: string;
    parameters?: Record<string, unknown>;
}, fn: () => Promise<T>): Promise<T>;
/**
 * Trace a chain/workflow
 */
export declare function traceChain<T>(options: {
    name: string;
    input?: unknown;
}, fn: () => Promise<T>): Promise<T>;
/**
 * Issues API client
 * This is the recommended API for managing clustered failure patterns
 *
 * @since 3.1.0
 */
export declare const issues: {
    /**
     * List issues for an agent
     */
    list(agentId: string, options?: {
        status?: string;
        startDate?: Date;
        endDate?: Date;
        limit?: number;
        offset?: number;
    }): Promise<any[]>;
    /**
     * Get a single issue by ID
     */
    get(id: string): Promise<any>;
    /**
     * Create a new issue
     */
    create(data: {
        agentId: string;
        title: string;
        description?: string;
        type: string;
        severity?: string;
        pattern?: string;
        exampleTraceIds?: string[];
    }): Promise<any>;
    /**
     * Update an issue
     */
    update(id: string, data: {
        title?: string;
        description?: string;
        status?: string;
        severity?: string;
        assignedTo?: string;
        resolutionNotes?: string;
    }): Promise<any>;
    /**
     * Get fixes for an issue
     */
    getFixes(issueId: string): Promise<any[]>;
};
/**
 * Analyzer API client
 * User-selected trace analysis with cost estimation and smart sampling
 *
 * Key improvements over v1 Explainer:
 * - User-selected trace analysis (not automatic)
 * - Cost estimation before execution
 * - Smart sampling strategies
 * - Root cause analysis by layer
 * - Pattern aggregation across traces
 *
 * @since 3.1.0
 */
export declare const analyzer: {
    /**
     * Analyze specific traces (user-selected)
     */
    analyze(options: {
        traceIds: string[];
        tier?: "fast" | "standard" | "deep";
        includeRootCause?: boolean;
        includeLayers?: boolean;
    }): Promise<any>;
    /**
     * Analyze traces by time window
     */
    analyzeWindow(options: {
        agentId: string;
        startDate: Date;
        endDate: Date;
        filters?: {
            outcomes?: ("failure" | "error" | "success")[];
            minSeverity?: "low" | "medium" | "high" | "critical";
        };
        sampling?: {
            strategy: "all" | "failures_only" | "smart" | "random";
            samplePercent?: number;
        };
    }): Promise<any>;
    /**
     * Estimate cost before running analysis
     */
    estimateCost(options: {
        traceIds?: string[];
        agentId?: string;
        startDate?: Date;
        endDate?: Date;
        tier: "fast" | "standard" | "deep";
    }): Promise<{
        estimatedTraces: number;
        estimatedTokens: number;
        estimatedCost: number;
        estimatedCredits: number;
        tier: string;
        note: string;
    }>;
    /**
     * Get analysis results for a specific trace
     */
    get(traceId: string): Promise<any>;
    /**
     * Aggregate insights across multiple analyzed traces
     */
    summarize(options: {
        analysisIds?: string[];
        agentId?: string;
        startDate?: Date;
        endDate?: Date;
    }): Promise<any>;
};
export { isInitialized, SDK_VERSION, DEFAULT_ENDPOINT };
export { runs, claims, calibration, linking, customerContext, humanReview, nondeterminism, evalHealth, deterministicGraders, conversationEval, transcriptPatterns, apiKeys, agents, roiAnalytics, qualityMetrics, businessMetrics, evalRuns, signals, notifications, documents, shadowTests, sessions, drift, llmCosts, guardrails, };
export { createRunWithContext, toOpenAIMessages, fromOpenAIMessages, isFact, isInference, isComputed, getHighConfidenceClaims, groupClaimsByType, groupClaimsByCategory, calculateBrierScore, calculateECE, isWellCalibrated, getCalibrationQuality, generateZendeskMarker, parseZendeskMarker, hasZendeskMarker, removeZendeskMarker, linkRunToTicket, linkRunToZendeskTicket, getBestLinkMethod, LINK_METHOD_CONFIDENCE, captureCustomerContext, getContextAsOf, toContextSnapshot, calculateArrChange, calculateHealthTrend, calculatePassAtK, calculatePassToK, requiredPassRateForPassAtK, isReliableEvaluation, getReliabilityRecommendation, hasHealthIssue, getHealthSeverityLevel, isSaturated, getSaturationRecommendation, createRegexRule, createContainsRule, createLengthRule, createJsonSchemaRule, allRulesPassed, getFailedRules, calculateAverageScore, aggregateWorst, aggregateAverage, aggregateWeighted, aggregateFinalTurn, aggregateMajority, getAggregator, getProblematicTurns, analyzeConversationTrend, isHighRisk, getMatchesByCategory, getCriticalInsights, hasPiiExposure, hasFrustrationSignals, hasEscalationRequest, getCategoryDistribution, getRecommendations, needsAttention, sortMatchesBySeverity, hasPermission, isApiKeyExpired, isApiKeyValid, getTimeUntilExpiry, canAccessAgent, calculateRevenueAtRisk, calculateAutomationSavings, formatCurrency, getROIQuality, passesQualityThreshold, isHallucinationRiskAcceptable, getQualityRecommendations, formatQualityScore, getGradeColor, isMetricReady, needsMoreTraces, awaitingExternalData, isMetricStale, getStatusMessage, getTraceProgress, formatMetricValue, getTrendEmoji, hasDrift, getDriftSeverity, formatLLMCost, };
export { type ScanRequest, type ScanResponse, type Finding, type ScannerResult } from './guardrails';
export { ThinkHiveError, ThinkHiveApiError, ThinkHiveValidationError, PermissionDeniedError, AgentScopeError, RateLimitError, IpWhitelistError, };
declare const _default: {
    init: typeof init;
    getTracer: typeof getTracer;
    shutdown: typeof shutdown;
    isInitialized: typeof isInitialized;
    traceLLM: typeof traceLLM;
    traceRetrieval: typeof traceRetrieval;
    traceTool: typeof traceTool;
    traceChain: typeof traceChain;
    runs: {
        create(options: import("./core/types").RunOptions): Promise<import("./core/types").RunResponse>;
        get(runId: string): Promise<import("./core/types").RunResponse>;
        list(options?: import("./api/runs").ListRunsOptions): Promise<{
            items: import("./core/types").RunResponse[];
            limit: number;
            offset: number;
            hasMore: boolean;
        }>;
        update(runId: string, updates: Partial<Pick<import("./core/types").RunOptions, "outcome" | "outcomeReason" | "endedAt" | "metadata">>): Promise<import("./core/types").RunResponse>;
        delete(runId: string): Promise<void>;
        batch(runsData: import("./core/types").RunOptions[]): Promise<{
            created: import("./core/types").RunResponse[];
            failed: Array<{
                index: number;
                error: string;
            }>;
        }>;
        stats(agentId: string, options?: {
            from?: string | Date;
            to?: string | Date;
        }): Promise<import("./api/runs").RunStats>;
        getTraces(runId: string): Promise<unknown[]>;
        addTrace(runId: string, traceData: {
            spans?: unknown[];
            timestamp?: string;
            metadata?: Record<string, unknown>;
        }): Promise<{
            traceId: string;
        }>;
    };
    claims: {
        createAnalysis(options: import("./api/claims").CreateAnalysisOptions): Promise<import("./core/types").AnalysisResult>;
        getAnalysis(analysisId: string): Promise<import("./core/types").AnalysisResult>;
        getRunAnalysis(runId: string): Promise<import("./core/types").AnalysisResult>;
        getAnalysisHistory(runId: string): Promise<{
            runId: string;
            analyses: Array<{
                id: string;
                analysisVersion: string;
                modelUsed: string;
                outcomeVerdict: string;
                isCurrent: boolean;
                supersededBy?: string;
                supersessionReason?: string;
                analyzedAt: string;
            }>;
        }>;
        supersedeAnalysis(analysisId: string, options: {
            reason: string;
            newAnalysis: Omit<import("./api/claims").CreateAnalysisOptions, "runId">;
        }): Promise<{
            supersededAnalysisId: string;
            newAnalysis: import("./core/types").AnalysisResult;
        }>;
        list(options?: import("./api/claims").ListClaimsOptions): Promise<{
            claims: import("./core/types").Claim[];
            limit: number;
            offset: number;
            hasMore: boolean;
        }>;
        get(claimId: string): Promise<import("./core/types").Claim>;
        verify(claimId: string, options: {
            verdict: "confirmed" | "rejected" | "modified";
            notes?: string;
            modifiedText?: string;
        }): Promise<{
            claimId: string;
            verdict: string;
            message: string;
        }>;
        summary(options?: {
            runId?: string;
            analysisIds?: string[];
        }): Promise<import("./api/claims").FactsVsInferencesSummary>;
    };
    calibration: {
        status(agentId: string, predictionType: import("./core/types").PredictionType): Promise<import("./core/types").CalibrationStatus>;
        allMetrics(agentId: string): Promise<import("./api/calibration").CalibrationMetrics[]>;
        retrain(agentId: string, options?: {
            predictionTypes?: import("./core/types").PredictionType[];
            minSamples?: number;
        }): Promise<{
            success: boolean;
            retrainedTypes: import("./core/types").PredictionType[];
            skippedTypes: Array<{
                type: import("./core/types").PredictionType;
                reason: string;
            }>;
            newMetrics: import("./api/calibration").CalibrationMetrics[];
        }>;
    };
    linking: {
        create(input: import("./integrations/ticket-linking").CreateLinkInput): Promise<import("./integrations/ticket-linking").LinkResponse>;
        getForRun(runId: string): Promise<import("./integrations/ticket-linking").LinkResponse[]>;
        getForTicket(ticketId: string): Promise<import("./integrations/ticket-linking").LinkResponse[]>;
        verify(linkId: string, options: {
            verified: boolean;
            notes?: string;
        }): Promise<import("./integrations/ticket-linking").LinkResponse>;
        delete(linkId: string): Promise<void>;
        autoLink(runId: string): Promise<import("./integrations/ticket-linking").LinkResponse | null>;
        stats(): Promise<{
            totalLinks: number;
            byMethod: Record<string, number>;
            avgConfidence: number;
            verifiedCount: number;
            unverifiedCount: number;
        }>;
        generateMarker(options: {
            traceId: string;
            runId?: string;
            format?: "html_comment" | "base64" | "custom";
            customTemplate?: string;
        }): Promise<{
            marker: string;
            format: string;
            traceId: string;
            runId: string | null;
            instructions: string;
        }>;
    };
    customerContext: {
        createAccount(input: {
            name: string;
            externalId?: string;
            externalSource?: import("./integrations/customer-context").CustomerAccount["externalSource"];
            domain?: string;
            segment?: string;
            industry?: string;
            employeeCount?: number;
        }): Promise<import("./integrations/customer-context").CustomerAccount>;
        getAccount(customerId: string): Promise<import("./integrations/customer-context").CustomerAccount>;
        getAccountByExternalId(externalId: string, source: import("./integrations/customer-context").CustomerAccount["externalSource"]): Promise<import("./integrations/customer-context").CustomerAccount | null>;
        captureSnapshot(customerId: string, metrics: {
            arr?: number;
            healthScore?: number;
            nps?: number;
            segment?: string;
            churnRisk?: "low" | "medium" | "high";
            source?: string;
        }): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot>;
        getSnapshots(customerId: string, options?: {
            from?: string;
            to?: string;
            limit?: number;
        }): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot[]>;
        getLatestSnapshot(customerId: string): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot | null>;
        getSnapshotAsOf(customerId: string, timestamp: string | Date): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot | null>;
        capture(customerId: string, metrics: Record<string, unknown>): Promise<import("./core/types").CustomerContextSnapshot>;
    };
    humanReview: {
        getQueue(options?: import("./api/human-review").ListQueueOptions): Promise<import("./api/human-review").HumanReviewQueueItem[]>;
        addToQueue(options: import("./api/human-review").AddToQueueOptions): Promise<import("./api/human-review").HumanReviewQueueItem>;
        getItem(itemId: string): Promise<import("./api/human-review").HumanReviewQueueItem>;
        claim(itemId: string): Promise<import("./api/human-review").HumanReviewQueueItem>;
        release(itemId: string): Promise<import("./api/human-review").HumanReviewQueueItem>;
        skip(itemId: string): Promise<import("./api/human-review").HumanReviewQueueItem>;
        submit(itemId: string, review: import("./api/human-review").SubmitReviewOptions): Promise<import("./api/human-review").HumanReviewQueueItem>;
        getStats(agentId?: string): Promise<import("./api/human-review").QueueStats>;
        getNextItem(agentId?: string): Promise<import("./api/human-review").HumanReviewQueueItem | null>;
        getReviewTypes(): Promise<Array<{
            id: string;
            name: string;
            description: string;
            autoTrigger: boolean;
        }>>;
        getCalibrationSets(agentId?: string): Promise<import("./api/human-review").CalibrationSet[]>;
        createCalibrationSet(options: import("./api/human-review").CreateCalibrationSetOptions): Promise<import("./api/human-review").CalibrationSet>;
        getCalibrationSet(setId: string): Promise<import("./api/human-review").CalibrationSet>;
        getCertifiedReviewers(calibrationSetId: string): Promise<import("./api/human-review").ReviewerCalibration[]>;
        getReviewerCalibrations(userId: string): Promise<import("./api/human-review").ReviewerCalibration[]>;
    };
    nondeterminism: {
        createRun(options: import("./api/nondeterminism").CreateRunOptions): Promise<import("./api/nondeterminism").NondeterminismRun>;
        getRuns(options?: import("./api/nondeterminism").ListRunsOptions): Promise<import("./api/nondeterminism").NondeterminismRun[]>;
        getRun(runId: string): Promise<import("./api/nondeterminism").NondeterminismRun>;
        startRun(runId: string): Promise<void>;
        completeRun(runId: string): Promise<void>;
        recordSample(options: import("./api/nondeterminism").RecordSampleOptions): Promise<import("./api/nondeterminism").NondeterminismSample>;
        getSamples(runId: string): Promise<import("./api/nondeterminism").NondeterminismSample[]>;
        getRunSummary(runId: string): Promise<import("./api/nondeterminism").RunSummary>;
        analyzeRun(runId: string): Promise<import("./api/nondeterminism").RunSummary>;
        getInfo(): Promise<import("./api/nondeterminism").PassAtKInfo>;
    };
    evalHealth: {
        getReport(agentId: string): Promise<import("./api/eval-health").HealthReport>;
        getSnapshots(options: import("./api/eval-health").GetSnapshotsOptions): Promise<import("./api/eval-health").EvalHealthSnapshot[]>;
        getLatestSnapshot(agentId: string, criterionId?: string): Promise<import("./api/eval-health").EvalHealthSnapshot | null>;
        recordSnapshot(options: import("./api/eval-health").CreateSnapshotOptions): Promise<import("./api/eval-health").EvalHealthSnapshot>;
        getRegressions(agentId: string): Promise<import("./api/eval-health").EvalRegression[]>;
        recordRegression(options: import("./api/eval-health").CreateRegressionOptions): Promise<import("./api/eval-health").EvalRegression>;
        resolveRegression(regressionId: string, options: import("./api/eval-health").ResolveRegressionOptions): Promise<void>;
        acknowledgeRegression(regressionId: string): Promise<void>;
    };
    deterministicGraders: {
        evaluate(options: import("./api/deterministic-graders").EvaluateOptions): Promise<import("./api/deterministic-graders").DeterministicEvalResult>;
        bulkEvaluate(options: import("./api/deterministic-graders").BulkEvaluateOptions): Promise<import("./api/deterministic-graders").BulkEvaluateResult>;
        getRuleTypes(): Promise<import("./api/deterministic-graders").RuleTypeInfo[]>;
        getTemplates(): Promise<import("./api/deterministic-graders").RuleTemplate[]>;
    };
    conversationEval: {
        getSessionTraces(sessionId: string): Promise<import("./api/conversation-eval").SessionTrace[]>;
        evaluate(options: import("./api/conversation-eval").EvaluateConversationOptions): Promise<import("./api/conversation-eval").ConversationEvalResult>;
        getAggregationMethods(): Promise<import("./api/conversation-eval").AggregationMethodInfo[]>;
    };
    transcriptPatterns: {
        analyze(traceId: string): Promise<import("./api/transcript-patterns").AnalysisResult>;
        bulkAnalyze(traceIds: string[]): Promise<import("./api/transcript-patterns").BulkAnalysisResult>;
        getCategories(): Promise<import("./api/transcript-patterns").PatternCategoryInfo[]>;
        getBuiltInPatterns(): Promise<import("./api/transcript-patterns").BuiltInPattern[]>;
    };
    apiKeys: {
        create: typeof import("./api/apiKeys").create;
        list: typeof import("./api/apiKeys").list;
        revoke: typeof import("./api/apiKeys").revoke;
        rotate: typeof import("./api/apiKeys").rotate;
        test: typeof import("./api/apiKeys").test;
        hasPermission: typeof hasPermission;
        isExpired: typeof isApiKeyExpired;
        isValid: typeof isApiKeyValid;
        getTimeUntilExpiry: typeof getTimeUntilExpiry;
        canAccessAgent: typeof canAccessAgent;
    };
    agents: {
        list(options?: {
            companyId?: string;
            departmentId?: string;
        }): Promise<import("./api/agents").Agent[]>;
        get(id: string): Promise<import("./api/agents").Agent>;
        create(options: import("./api/agents").CreateAgentOptions): Promise<import("./api/agents").Agent>;
        update(id: string, options: import("./api/agents").UpdateAgentOptions): Promise<import("./api/agents").Agent>;
        delete(id: string, options?: import("./api/agents").DeleteAgentOptions): Promise<void | import("./api/agents").CascadeImpact>;
        getConfig(agentId: string): Promise<import("./api/agents").AgentConfig | null>;
        updateConfig(agentId: string, config: import("./api/agents").UpdateAgentConfigOptions): Promise<import("./api/agents").AgentConfig>;
    };
    issues: {
        /**
         * List issues for an agent
         */
        list(agentId: string, options?: {
            status?: string;
            startDate?: Date;
            endDate?: Date;
            limit?: number;
            offset?: number;
        }): Promise<any[]>;
        /**
         * Get a single issue by ID
         */
        get(id: string): Promise<any>;
        /**
         * Create a new issue
         */
        create(data: {
            agentId: string;
            title: string;
            description?: string;
            type: string;
            severity?: string;
            pattern?: string;
            exampleTraceIds?: string[];
        }): Promise<any>;
        /**
         * Update an issue
         */
        update(id: string, data: {
            title?: string;
            description?: string;
            status?: string;
            severity?: string;
            assignedTo?: string;
            resolutionNotes?: string;
        }): Promise<any>;
        /**
         * Get fixes for an issue
         */
        getFixes(issueId: string): Promise<any[]>;
    };
    analyzer: {
        /**
         * Analyze specific traces (user-selected)
         */
        analyze(options: {
            traceIds: string[];
            tier?: "fast" | "standard" | "deep";
            includeRootCause?: boolean;
            includeLayers?: boolean;
        }): Promise<any>;
        /**
         * Analyze traces by time window
         */
        analyzeWindow(options: {
            agentId: string;
            startDate: Date;
            endDate: Date;
            filters?: {
                outcomes?: ("failure" | "error" | "success")[];
                minSeverity?: "low" | "medium" | "high" | "critical";
            };
            sampling?: {
                strategy: "all" | "failures_only" | "smart" | "random";
                samplePercent?: number;
            };
        }): Promise<any>;
        /**
         * Estimate cost before running analysis
         */
        estimateCost(options: {
            traceIds?: string[];
            agentId?: string;
            startDate?: Date;
            endDate?: Date;
            tier: "fast" | "standard" | "deep";
        }): Promise<{
            estimatedTraces: number;
            estimatedTokens: number;
            estimatedCost: number;
            estimatedCredits: number;
            tier: string;
            note: string;
        }>;
        /**
         * Get analysis results for a specific trace
         */
        get(traceId: string): Promise<any>;
        /**
         * Aggregate insights across multiple analyzed traces
         */
        summarize(options: {
            analysisIds?: string[];
            agentId?: string;
            startDate?: Date;
            endDate?: Date;
        }): Promise<any>;
    };
    roiAnalytics: {
        summary(options?: {
            startDate?: string | Date;
            endDate?: string | Date;
            agentId?: string;
        }): Promise<import("./api/roi-analytics").ROISummary>;
        byAgent(agentId: string, options?: {
            startDate?: string | Date;
            endDate?: string | Date;
        }): Promise<{
            agent: {
                id: string;
                name: string;
                industry: string;
            };
            industryConfig: Partial<import("./api/roi-analytics").IndustryConfig>;
            roi: import("./api/roi-analytics").ROIMetrics;
            recentImpacts: Array<{
                impactScore: number;
                revenueRisk: number;
                roiCategory: string;
                totalFinancialImpact: number;
            }>;
        }>;
        trends(options?: {
            startDate?: string | Date;
            endDate?: string | Date;
            agentId?: string;
        }): Promise<import("./api/roi-analytics").TrendDataPoint[]>;
        calculate(options: {
            traceId?: string;
            userMessage?: string;
            agentResponse?: string;
            industryConfig?: import("./api/roi-analytics").CustomIndustryConfig;
        }): Promise<import("./api/roi-analytics").BusinessImpact>;
        industries(): Promise<import("./api/roi-analytics").IndustryConfig[]>;
        correlations(options?: {
            startDate?: string | Date;
            endDate?: string | Date;
            agentId?: string;
        }): Promise<import("./api/roi-analytics").CorrelationAnalysis>;
        getConfig(): Promise<{
            id: string;
            companyId: string;
            version: number;
            isActive: boolean;
            costConfig: Record<string, unknown>;
            deflectionConfig: Record<string, unknown>;
            resolutionConfig: Record<string, unknown>;
            attributionConfig: Record<string, unknown>;
            slaConfig: Record<string, unknown>;
            displayConfig: Record<string, unknown>;
            createdAt: string;
            updatedAt: string;
        }>;
        createConfig(data: {
            costConfig?: Record<string, unknown>;
            deflectionConfig?: Record<string, unknown>;
            resolutionConfig?: Record<string, unknown>;
            attributionConfig?: Record<string, unknown>;
            slaConfig?: Record<string, unknown>;
            displayConfig?: Record<string, unknown>;
        }): Promise<{
            id: string;
            companyId: string;
            version: number;
            isActive: boolean;
            costConfig: Record<string, unknown>;
            deflectionConfig: Record<string, unknown>;
            resolutionConfig: Record<string, unknown>;
            attributionConfig: Record<string, unknown>;
            slaConfig: Record<string, unknown>;
            displayConfig: Record<string, unknown>;
            createdAt: string;
            updatedAt: string;
        }>;
        updateConfig(data: {
            costConfig?: Record<string, unknown>;
            deflectionConfig?: Record<string, unknown>;
            resolutionConfig?: Record<string, unknown>;
            attributionConfig?: Record<string, unknown>;
            slaConfig?: Record<string, unknown>;
            displayConfig?: Record<string, unknown>;
        }): Promise<{
            id: string;
            companyId: string;
            version: number;
            isActive: boolean;
            costConfig: Record<string, unknown>;
            deflectionConfig: Record<string, unknown>;
            resolutionConfig: Record<string, unknown>;
            attributionConfig: Record<string, unknown>;
            slaConfig: Record<string, unknown>;
            displayConfig: Record<string, unknown>;
            createdAt: string;
            updatedAt: string;
        }>;
        configVersions(options?: {
            limit?: number;
            offset?: number;
        }): Promise<{
            data: Record<string, unknown>[];
            pagination: {
                limit: number;
                offset: number;
                hasMore: boolean;
            };
        }>;
        calculateV3(options: {
            agentId
            /**
             * Trace an LLM call
             */
            ?: string;
            startDate: string | Date;
            endDate: string | Date;
            configurationVersion?: number;
            includeBreakdown?: boolean;
            includeConfidenceIntervals?: boolean;
        }): Promise<Record<string, unknown>>;
        trendV3(options: {
            agentId?: string;
            granularity: "day" | "week" | "month";
            startDate: string | Date;
            endDate: string | Date;
        }): Promise<Record<string, unknown>>;
    };
    qualityMetrics: {
        getRagScores(traceId: string): Promise<{
            traceId: string;
            evaluation: import("./api/quality-metrics").RAGEvaluation;
            evidence: import("./api/quality-metrics").RAGEvidence;
        }>;
        getHallucinationReport(traceId: string): Promise<{
            traceId: string;
            report: import("./api/quality-metrics").HallucinationReport;
        }>;
        evaluateRag(input: {
            query: string;
            response: string;
            retrievedContexts: import("./api/quality-metrics").RetrievedContext[];
            groundTruthContexts?: import("./api/quality-metrics").GroundTruthContext[];
            citations?: string[];
        }): Promise<{
            evaluation: import("./api/quality-metrics").RAGEvaluation;
            evidence: import("./api/quality-metrics").RAGEvidence;
        }>;
        detectHallucinations(input: {
            response: string;
            contexts: Array<{
                content: string;
                metadata?: Record<string, unknown>;
            }>;
            query?: string;
            previousResponses?: string[];
        }): Promise<{
            report: import("./api/quality-metrics").HallucinationReport;
        }>;
        getGroundedness(traceId: string): Promise<{
            traceId: string;
            groundedness: import("./api/quality-metrics").GroundednessResult;
            spans: {
                grounded: Array<{
                    text: string;
                    confidence: number;
                    sourceIndex: number;
                }>;
                ungrounded: Array<{
                    text: string;
                    confidence: number;
                }>;
            };
            summary: {
                totalSpans: number;
                groundedSpans: number;
                ungroundedSpans: number;
                groundednessRatio: number;
            };
        }>;
        evaluateBatch(options: {
            traceIds: string[];
            includeDetails?: boolean;
        }): Promise<{
            summary: import("./api/quality-metrics").BatchEvaluationSummary;
            results: import("./api/quality-metrics").BatchEvaluationResult[];
        }>;
        evaluate(input: {
            query: string;
            response: string;
            retrievedContexts: import("./api/quality-metrics").RetrievedContext[];
            groundTruthContexts?: import("./api/quality-metrics").GroundTruthContext[];
            citations?: string[];
        }): Promise<{
            evaluation: import("./api/quality-metrics").RAGEvaluation;
            evidence: import("./api/quality-metrics").RAGEvidence;
        }>;
    };
    businessMetrics: {
        current(agentId: string, metricName?: string): Promise<import("./api/business-metrics").CurrentMetricResponse>;
        history(agentId: string, metricName: string, options?: {
            startDate?: string | Date;
            endDate?: string | Date;
            granularity?: "hourly" | "daily" | "weekly" | "monthly";
        }): Promise<import("./api/business-metrics").MetricHistoryResponse>;
        record(agentId: string, options: import("./api/business-metrics").RecordMetricOptions): Promise<import("./api/business-metrics").RecordMetricResponse>;
        recordBatch(agentId: string, metrics: import("./api/business-metrics").RecordMetricOptions[]): Promise<import("./api/business-metrics").RecordMetricResponse[]>;
    };
    evalRuns: {
        create(agentId: string, opts?: import("./api/eval-runs").CreateEvalRunOptions): Promise<import("./api/eval-runs").EvalRun>;
        get(runId: string): Promise<import("./api/eval-runs").EvalRun>;
        getResults(runId: string, opts?: import("./api/eval-runs").GetEvalRunResultsOptions): Promise<{
            results: import("./api/eval-runs").EvalResult[];
            limit: number;
            offset: number;
            hasMore: boolean;
        }>;
        list(opts?: import("./api/eval-runs").ListEvalRunsOptions): Promise<import("./api/eval-runs").EvalRun[]>;
        estimateCost(agentId: string, opts?: import("./api/eval-runs").EstimateCostOptions): Promise<import("./api/eval-runs").EvalCostEstimate>;
        getTraceResults(traceId: string, opts?: import("./api/eval-runs").GetTraceResultsOptions): Promise<import("./api/eval-runs").EvalResult[]>;
        remove(runId: string): Promise<void>;
    };
    signals: {
        list(opts?: import("./api/signals").ListSignalsOptions): Promise<import("./api/signals").Signal[]>;
        create(name: string, group: string, detectionConfig: import("./api/signals").DetectionConfig, opts?: import("./api/signals").CreateSignalOptions): Promise<import("./api/signals").Signal>;
        update(id: string, opts: import("./api/signals").UpdateSignalOptions): Promise<import("./api/signals").Signal>;
        remove(id: string): Promise<void>;
        delete(id: string): Promise<void>;
        seedDefaults(): Promise<import("./api/signals").Signal[]>;
        getStats(opts?: import("./api/signals").SignalStatsOptions): Promise<import("./api/signals").SignalStats[]>;
        getTrends(opts?: import("./api/signals").SignalTrendsOptions): Promise<import("./api/signals").SignalTrendPoint[]>;
        getTraces(id: string, opts?: import("./api/signals").SignalTracesOptions): Promise<{
            traces: any[];
            limit: number;
            offset: number;
            hasMore: boolean;
        }>;
        getEvents(id: string, opts?: import("./api/signals").SignalEventsOptions): Promise<{
            events: import("./api/signals").SignalEvent[];
            limit: number;
            offset: number;
            hasMore: boolean;
        }>;
    };
    notifications: {
        listRules(agentId: string): Promise<import("./api/notifications").NotificationRule[]>;
        getRule(id: string, agentId?: string): Promise<import("./api/notifications").NotificationRule>;
        createRule(data: import("./api/notifications").CreateNotificationRuleData): Promise<import("./api/notifications").NotificationRule>;
        updateRule(id: string, data: import("./api/notifications").UpdateNotificationRuleData): Promise<import("./api/notifications").NotificationRule>;
        deleteRule(id: string): Promise<void>;
        listNotifications(agentId: string, unreadOnly?: boolean): Promise<import("./api/notifications").Notification[]>;
        markAsRead(id: string): Promise<import("./api/notifications").Notification>;
        list(agentId: string, unreadOnly?: boolean): Promise<import("./api/notifications").Notification[]>;
    };
    documents: {
        list(agentId: string): Promise<import("./api/documents").Document[]>;
        upload(agentId: string, fileName: string, fileType: string, fileSize: number): Promise<import("./api/documents").DocumentUploadResponse>;
        remove(agentId: string, docId: string): Promise<void>;
    };
    shadowTests: {
        list(agentId: string): Promise<import("./api/shadow-tests").ShadowTest[]>;
        get(id: string): Promise<import("./api/shadow-tests").ShadowTest>;
        getByFix(fixId: string): Promise<import("./api/shadow-tests").ShadowTest[]>;
        create(data: import("./api/shadow-tests").CreateShadowTestData): Promise<import("./api/shadow-tests").ShadowTest>;
        update(id: string, data: import("./api/shadow-tests").UpdateShadowTestData): Promise<import("./api/shadow-tests").ShadowTest>;
    };
    sessions: {
        list(agentId: string, opts?: import("./api/sessions").ListSessionsOptions): Promise<{
            sessions: import("./api/sessions").Session[];
            limit: number;
            offset: number;
            hasMore: boolean;
        }>;
        getTraces(sessionId: string, agentId: string): Promise<import("./api/sessions").SessionTrace[]>;
    };
    drift: {
        detect(agentId: string, opts?: import("./api/drift").DetectDriftOptions): Promise<import("./api/drift").DriftReport>;
        detectAll(): Promise<import("./api/drift").DetectAllResult>;
    };
    llmCosts: {
        getSummary(opts?: import("./api/llm-costs").CostQueryOptions): Promise<import("./api/llm-costs").CostSummary>;
        getBreakdown(agentId: string, opts?: import("./api/llm-costs").CostQueryOptions): Promise<import("./api/llm-costs").AgentCostBreakdown>;
        getSavings(): Promise<import("./api/llm-costs").CostSavings>;
        getOptimizationStats(): Promise<import("./api/llm-costs").OptimizationStats>;
        summary(opts?: import("./api/llm-costs").CostQueryOptions): Promise<import("./api/llm-costs").CostSummary>;
    };
    guardrails: {
        scan(request: import("./guardrails").ScanRequest): Promise<import("./guardrails").ScanResponse>;
        listScanners(): Promise<Array<{
            name: string;
            description: string;
        }>>;
        evaluate(request: import("./guardrails").ScanRequest): Promise<import("./guardrails").ScanResponse>;
    };
    generateZendeskMarker: typeof generateZendeskMarker;
    parseZendeskMarker: typeof parseZendeskMarker;
    linkRunToTicket: typeof linkRunToTicket;
    createRunWithContext: typeof createRunWithContext;
    isFact: typeof isFact;
    isInference: typeof isInference;
    calculateBrierScore: typeof calculateBrierScore;
    isWellCalibrated: typeof isWellCalibrated;
    calculatePassAtK: typeof calculatePassAtK;
    isReliableEvaluation: typeof isReliableEvaluation;
    isHighRisk: typeof isHighRisk;
    needsAttention: typeof needsAttention;
    calculateRevenueAtRisk: typeof calculateRevenueAtRisk;
    formatCurrency: typeof formatCurrency;
    passesQualityThreshold: typeof passesQualityThreshold;
    isHallucinationRiskAcceptable: typeof isHallucinationRiskAcceptable;
    isMetricReady: typeof isMetricReady;
    needsMoreTraces: typeof needsMoreTraces;
    getStatusMessage: typeof getStatusMessage;
    hasDrift: typeof hasDrift;
    getDriftSeverity: typeof getDriftSeverity;
    formatLLMCost: typeof formatLLMCost;
};
export default _default;