@thinkhive/sdk 3.1.1 → 4.0.0

package/dist/index.d.ts

@@ -11,13 +11,35 @@
  * @license MIT
  */
 import { isInitialized, SDK_VERSION, DEFAULT_ENDPOINT } from './core/config';
-import { ThinkHiveApiError, ThinkHiveValidationError } from './core/client';
+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 { 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, SpanData, BusinessContext, Claim, ClaimType, ClaimCategory, ConfidenceCalibration, EvidenceReference, AnalysisResult, CalibrationStatus, CalibrationBucket, PredictionType, RoiConfig, RoiSummary, ExplainabilityResult, ApiResponse, PaginatedResponse, RunResponse, } from './core/types';
+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';
 /**
  * Initialize ThinkHive SDK v3
  *
@@ -75,52 +97,128 @@ export declare function traceChain<T>(options: {
     input?: unknown;
 }, fn: () => Promise<T>): Promise<T>;
 /**
- * Explainer API client (v2 compatibility)
- * @deprecated Use runs and claims APIs instead
+ * Issues API client
+ * This is the recommended API for managing clustered failure patterns
+ *
+ * @since 3.1.0
  */
-export declare const explainer: {
+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>;
     /**
-     * Analyze a trace (v2 format)
-     * @deprecated Use runs.create() + claims.getRunAnalysis() instead
+     * Create a new issue
      */
-    analyze(traceData: import("./core/types").TraceOptions, options?: {
-        tier?: string;
-        includeRagEvaluation?: boolean;
-        includeHallucinationCheck?: boolean;
-        waitForResult?: boolean;
-        webhookUrl?: string;
-    }): Promise<import("./core/types").ExplainabilityResult>;
+    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: {
     /**
-     * Get a previously analyzed trace
-     * @deprecated
+     * Analyze specific traces (user-selected)
      */
-    get(traceId: string): Promise<import("./core/types").ExplainabilityResult>;
+    analyze(options: {
+        traceIds: string[];
+        tier?: "fast" | "standard" | "deep";
+        includeRootCause?: boolean;
+        includeLayers?: boolean;
+    }): Promise<any>;
     /**
-     * Search traces semantically
-     * @deprecated
+     * Analyze traces by time window
      */
-    search(params: {
-        query: string;
+    analyzeWindow(options: {
+        agentId: string;
+        startDate: Date;
+        endDate: Date;
         filters?: {
-            outcome?: string;
-            minImpactScore?: number;
-            dateRange?: {
-                from: Date;
-                to: Date;
-            };
+            outcomes?: ("failure" | "error" | "success")[];
+            minSeverity?: "low" | "medium" | "high" | "critical";
         };
-        limit?: number;
+        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<{
-        results: Array<import("./core/types").ExplainabilityResult & {
-            similarity: number;
-        }>;
-        total: number;
+        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, };
-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, };
-export { ThinkHiveApiError, ThinkHiveValidationError };
+export { runs, claims, calibration, linking, customerContext, humanReview, nondeterminism, evalHealth, deterministicGraders, conversationEval, transcriptPatterns, apiKeys, agents, roiAnalytics, qualityMetrics, businessMetrics, };
+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, };
+export { ThinkHiveError, ThinkHiveApiError, ThinkHiveValidationError, PermissionDeniedError, AgentScopeError, RateLimitError, IpWhitelistError, };
 declare const _default: {
     init: typeof init;
     getTracer: typeof getTracer;
@@ -209,11 +307,6 @@ declare const _default: {
     calibration: {
         status(agentId: string, predictionType: import("./core/types").PredictionType): Promise<import("./core/types").CalibrationStatus>;
         allMetrics(agentId: string): Promise<import("./api/calibration").CalibrationMetrics[]>;
-        recordOutcome(input: import("./api/calibration").RecordOutcomeInput): Promise<{
-            recorded: boolean;
-            brierContribution: number;
-            message: string;
-        }>;
         retrain(agentId: string, options?: {
             predictionTypes?: import("./core/types").PredictionType[];
             minSamples?: number;
@@ -226,15 +319,6 @@ declare const _default: {
             }>;
             newMetrics: import("./api/calibration").CalibrationMetrics[];
         }>;
-        reliabilityDiagram(agentId: string, predictionType: import("./core/types").PredictionType): Promise<{
-            agentId: string;
-            predictionType: import("./core/types").PredictionType;
-            buckets: import("./core/types").CalibrationBucket[];
-            perfectCalibrationLine: Array<{
-                x: number;
-                y: number;
-            }>;
-        }>;
     };
     linking: {
         create(input: import("./integrations/ticket-linking").CreateLinkInput): Promise<import("./integrations/ticket-linking").LinkResponse>;
@@ -288,44 +372,302 @@ declare const _default: {
         getLatestSnapshot(customerId: string): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot | null>;
         getSnapshotAsOf(customerId: string, timestamp: string | Date): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot | null>;
     };
-    explainer: {
+    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: {
         /**
-         * Analyze a trace (v2 format)
-         * @deprecated Use runs.create() + claims.getRunAnalysis() instead
+         * List issues for an agent
          */
-        analyze(traceData: import("./core/types").TraceOptions, options?: {
-            tier?: string;
-            includeRagEvaluation?: boolean;
-            includeHallucinationCheck?: boolean;
-            waitForResult?: boolean;
-            webhookUrl?: string;
-        }): Promise<import("./core/types").ExplainabilityResult>;
+        list(agentId: string, options?: {
+            status?: string;
+            startDate?: Date;
+            endDate?: Date;
+            limit?: number;
+            offset?: number;
+        }): Promise<any[]>;
         /**
-         * Get a previously analyzed trace
-         * @deprecated
+         * Get a single issue by ID
          */
-        get(traceId: string): Promise<import("./core/types").ExplainabilityResult>;
+        get(id: string): Promise<any>;
         /**
-         * Search traces semantically
-         * @deprecated
+         * Create a new issue
          */
-        search(params: {
-            query: string;
+        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?: {
-                outcome?: string;
-                minImpactScore?: number;
-                dateRange?: {
-                    from: Date;
-                    to: Date;
-                };
+                outcomes?: ("failure" | "error" | "success")[];
+                minSeverity?: "low" | "medium" | "high" | "critical";
             };
-            limit?: number;
+            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<{
-            results: Array<import("./core/types").ExplainabilityResult & {
-                similarity: number;
+            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;
             }>;
-            total: 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>;
+    };
+    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[];
+        }>;
+    };
+    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[]>;
     };
     generateZendeskMarker: typeof generateZendeskMarker;
     parseZendeskMarker: typeof parseZendeskMarker;
@@ -335,5 +677,16 @@ declare const _default: {
     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;
 };
 export default _default;