@thinkhive/sdk 2.0.1 → 3.1.0

package/dist/api/claims.d.ts

@@ -0,0 +1,262 @@
+/**
+ * ThinkHive SDK v3.0 - Claims API
+ *
+ * Facts vs Inferences API for accessing analysis claims
+ */
+import type { Claim, ClaimType, ClaimCategory, AnalysisResult, EvidenceReference } from '../core/types';
+/**
+ * List claims query options
+ */
+export interface ListClaimsOptions {
+    runId?: string;
+    analysisId?: string;
+    claimType?: ClaimType;
+    claimCategory?: ClaimCategory;
+    minConfidence?: number;
+    humanVerified?: boolean;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Create analysis options
+ */
+export interface CreateAnalysisOptions {
+    runId: string;
+    modelUsed?: string;
+    outcomeVerdict: 'success' | 'partial_success' | 'failure';
+    outcomeConfidence?: number;
+    rootCauseCategory?: string;
+    rootCauseConfidence?: number;
+    claims?: CreateClaimInput[];
+}
+export interface CreateClaimInput {
+    claimType: ClaimType;
+    claimCategory: ClaimCategory;
+    claimText: string;
+    confidence: number;
+    confidenceCalibration?: 'calibrated' | 'uncalibrated' | 'needs_more_data';
+    evidence?: EvidenceReference[];
+    isExplainable?: boolean;
+    probabilityValue?: number;
+}
+/**
+ * Facts vs inferences summary
+ */
+export interface FactsVsInferencesSummary {
+    analysisIds: string[];
+    totalClaims: number;
+    observed: {
+        count: number;
+        avgConfidence: number;
+        categories: Record<string, number>;
+    };
+    inferred: {
+        count: number;
+        avgConfidence: number;
+        categories: Record<string, number>;
+    };
+    computed: {
+        count: number;
+        avgConfidence: number;
+        categories: Record<string, number>;
+    };
+    humanVerifiedCount: number;
+    humanRejectedCount: number;
+}
+/**
+ * Claims API client for facts vs inferences management
+ */
+export declare const claims: {
+    /**
+     * Create a new analysis for a run
+     *
+     * @example
+     * ```typescript
+     * const analysis = await claims.createAnalysis({
+     *   runId: 'run_abc123',
+     *   outcomeVerdict: 'failure',
+     *   outcomeConfidence: 0.85,
+     *   rootCauseCategory: 'retrieval_failure',
+     *   claims: [
+     *     {
+     *       claimType: 'observed',
+     *       claimCategory: 'root_cause',
+     *       claimText: 'Vector search returned 0 results',
+     *       confidence: 1.0,
+     *       evidence: [{ type: 'span', referenceId: 'span_123', relevance: 'direct', confidence: 1.0 }],
+     *     },
+     *     {
+     *       claimType: 'inferred',
+     *       claimCategory: 'churn_risk',
+     *       claimText: 'High churn risk due to repeated failures',
+     *       confidence: 0.7,
+     *     },
+     *   ],
+     * });
+     * ```
+     */
+    createAnalysis(options: CreateAnalysisOptions): Promise<AnalysisResult>;
+    /**
+     * Get an analysis by ID
+     *
+     * @example
+     * ```typescript
+     * const analysis = await claims.getAnalysis('analysis_abc123');
+     * ```
+     */
+    getAnalysis(analysisId: string): Promise<AnalysisResult>;
+    /**
+     * Get current analysis for a run
+     *
+     * @example
+     * ```typescript
+     * const analysis = await claims.getRunAnalysis('run_abc123');
+     * ```
+     */
+    getRunAnalysis(runId: string): Promise<AnalysisResult>;
+    /**
+     * Get analysis history for a run
+     *
+     * @example
+     * ```typescript
+     * const history = await claims.getAnalysisHistory('run_abc123');
+     * ```
+     */
+    getAnalysisHistory(runId: string): Promise<{
+        runId: string;
+        analyses: Array<{
+            id: string;
+            analysisVersion: string;
+            modelUsed: string;
+            outcomeVerdict: string;
+            isCurrent: boolean;
+            supersededBy?: string;
+            supersessionReason?: string;
+            analyzedAt: string;
+        }>;
+    }>;
+    /**
+     * Supersede an analysis with a new one
+     *
+     * @example
+     * ```typescript
+     * const newAnalysis = await claims.supersedeAnalysis('analysis_old', {
+     *   reason: 'Improved model accuracy',
+     *   newAnalysis: {
+     *     outcomeVerdict: 'success',
+     *     outcomeConfidence: 0.95,
+     *     claims: [...],
+     *   },
+     * });
+     * ```
+     */
+    supersedeAnalysis(analysisId: string, options: {
+        reason: string;
+        newAnalysis: Omit<CreateAnalysisOptions, "runId">;
+    }): Promise<{
+        supersededAnalysisId: string;
+        newAnalysis: AnalysisResult;
+    }>;
+    /**
+     * List claims with filters
+     *
+     * @example
+     * ```typescript
+     * // Get all inferred claims with high confidence
+     * const { claims } = await claims.list({
+     *   claimType: 'inferred',
+     *   minConfidence: 0.8,
+     * });
+     *
+     * // Get all churn risk claims for a run
+     * const { claims } = await claims.list({
+     *   runId: 'run_abc123',
+     *   claimCategory: 'churn_risk',
+     * });
+     * ```
+     */
+    list(options?: ListClaimsOptions): Promise<{
+        claims: Claim[];
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get a claim by ID
+     *
+     * @example
+     * ```typescript
+     * const claim = await claims.get('claim_abc123');
+     * ```
+     */
+    get(claimId: string): Promise<Claim>;
+    /**
+     * Verify or reject a claim (human feedback)
+     *
+     * @example
+     * ```typescript
+     * // Confirm a claim
+     * await claims.verify('claim_abc123', {
+     *   verdict: 'confirmed',
+     *   notes: 'Verified against ticket history',
+     * });
+     *
+     * // Reject a claim
+     * await claims.verify('claim_abc123', {
+     *   verdict: 'rejected',
+     *   notes: 'Customer context was missing',
+     * });
+     * ```
+     */
+    verify(claimId: string, options: {
+        verdict: "confirmed" | "rejected" | "modified";
+        notes?: string;
+        modifiedText?: string;
+    }): Promise<{
+        claimId: string;
+        verdict: string;
+        message: string;
+    }>;
+    /**
+     * Get facts vs inferences summary
+     *
+     * @example
+     * ```typescript
+     * // Summary for a specific run
+     * const summary = await claims.summary({ runId: 'run_abc123' });
+     *
+     * // Summary for multiple analyses
+     * const summary = await claims.summary({
+     *   analysisIds: ['analysis_1', 'analysis_2'],
+     * });
+     * ```
+     */
+    summary(options?: {
+        runId?: string;
+        analysisIds?: string[];
+    }): Promise<FactsVsInferencesSummary>;
+};
+/**
+ * Check if a claim is a fact (observed)
+ */
+export declare function isFact(claim: Claim): boolean;
+/**
+ * Check if a claim is an inference
+ */
+export declare function isInference(claim: Claim): boolean;
+/**
+ * Check if a claim is computed
+ */
+export declare function isComputed(claim: Claim): boolean;
+/**
+ * Get high confidence claims (>= threshold)
+ */
+export declare function getHighConfidenceClaims(claimsList: Claim[], threshold?: number): Claim[];
+/**
+ * Group claims by type
+ */
+export declare function groupClaimsByType(claimsList: Claim[]): Record<ClaimType, Claim[]>;
+/**
+ * Group claims by category
+ */
+export declare function groupClaimsByCategory(claimsList: Claim[]): Record<ClaimCategory, Claim[]>;

package/dist/api/claims.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Claims API
+ *
+ * Facts vs Inferences API for accessing analysis claims
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claims = void 0;
+exports.isFact = isFact;
+exports.isInference = isInference;
+exports.isComputed = isComputed;
+exports.getHighConfidenceClaims = getHighConfidenceClaims;
+exports.groupClaimsByType = groupClaimsByType;
+exports.groupClaimsByCategory = groupClaimsByCategory;
+const client_1 = require("../core/client");
+/**
+ * Claims API client for facts vs inferences management
+ */
+exports.claims = {
+    /**
+     * Create a new analysis for a run
+     *
+     * @example
+     * ```typescript
+     * const analysis = await claims.createAnalysis({
+     *   runId: 'run_abc123',
+     *   outcomeVerdict: 'failure',
+     *   outcomeConfidence: 0.85,
+     *   rootCauseCategory: 'retrieval_failure',
+     *   claims: [
+     *     {
+     *       claimType: 'observed',
+     *       claimCategory: 'root_cause',
+     *       claimText: 'Vector search returned 0 results',
+     *       confidence: 1.0,
+     *       evidence: [{ type: 'span', referenceId: 'span_123', relevance: 'direct', confidence: 1.0 }],
+     *     },
+     *     {
+     *       claimType: 'inferred',
+     *       claimCategory: 'churn_risk',
+     *       claimText: 'High churn risk due to repeated failures',
+     *       confidence: 0.7,
+     *     },
+     *   ],
+     * });
+     * ```
+     */
+    async createAnalysis(options) {
+        return (0, client_1.apiRequestWithData)('/analyses', {
+            method: 'POST',
+            body: options,
+        });
+    },
+    /**
+     * Get an analysis by ID
+     *
+     * @example
+     * ```typescript
+     * const analysis = await claims.getAnalysis('analysis_abc123');
+     * ```
+     */
+    async getAnalysis(analysisId) {
+        return (0, client_1.apiRequestWithData)(`/analyses/${analysisId}`);
+    },
+    /**
+     * Get current analysis for a run
+     *
+     * @example
+     * ```typescript
+     * const analysis = await claims.getRunAnalysis('run_abc123');
+     * ```
+     */
+    async getRunAnalysis(runId) {
+        return (0, client_1.apiRequestWithData)(`/runs/${runId}/analysis`);
+    },
+    /**
+     * Get analysis history for a run
+     *
+     * @example
+     * ```typescript
+     * const history = await claims.getAnalysisHistory('run_abc123');
+     * ```
+     */
+    async getAnalysisHistory(runId) {
+        return (0, client_1.apiRequestWithData)(`/runs/${runId}/analyses`);
+    },
+    /**
+     * Supersede an analysis with a new one
+     *
+     * @example
+     * ```typescript
+     * const newAnalysis = await claims.supersedeAnalysis('analysis_old', {
+     *   reason: 'Improved model accuracy',
+     *   newAnalysis: {
+     *     outcomeVerdict: 'success',
+     *     outcomeConfidence: 0.95,
+     *     claims: [...],
+     *   },
+     * });
+     * ```
+     */
+    async supersedeAnalysis(analysisId, options) {
+        return (0, client_1.apiRequestWithData)(`/analyses/${analysisId}/supersede`, {
+            method: 'POST',
+            body: options,
+        });
+    },
+    /**
+     * List claims with filters
+     *
+     * @example
+     * ```typescript
+     * // Get all inferred claims with high confidence
+     * const { claims } = await claims.list({
+     *   claimType: 'inferred',
+     *   minConfidence: 0.8,
+     * });
+     *
+     * // Get all churn risk claims for a run
+     * const { claims } = await claims.list({
+     *   runId: 'run_abc123',
+     *   claimCategory: 'churn_risk',
+     * });
+     * ```
+     */
+    async list(options = {}) {
+        const params = new URLSearchParams();
+        if (options.runId)
+            params.set('runId', options.runId);
+        if (options.analysisId)
+            params.set('analysisId', options.analysisId);
+        if (options.claimType)
+            params.set('claimType', options.claimType);
+        if (options.claimCategory)
+            params.set('claimCategory', options.claimCategory);
+        if (options.minConfidence !== undefined) {
+            params.set('minConfidence', String(options.minConfidence));
+        }
+        if (options.humanVerified !== undefined) {
+            params.set('humanVerified', String(options.humanVerified));
+        }
+        if (options.limit)
+            params.set('limit', String(options.limit));
+        if (options.offset)
+            params.set('offset', String(options.offset));
+        const response = await (0, client_1.apiRequest)(`/claims?${params.toString()}`);
+        return response.data;
+    },
+    /**
+     * Get a claim by ID
+     *
+     * @example
+     * ```typescript
+     * const claim = await claims.get('claim_abc123');
+     * ```
+     */
+    async get(claimId) {
+        return (0, client_1.apiRequestWithData)(`/claims/${claimId}`);
+    },
+    /**
+     * Verify or reject a claim (human feedback)
+     *
+     * @example
+     * ```typescript
+     * // Confirm a claim
+     * await claims.verify('claim_abc123', {
+     *   verdict: 'confirmed',
+     *   notes: 'Verified against ticket history',
+     * });
+     *
+     * // Reject a claim
+     * await claims.verify('claim_abc123', {
+     *   verdict: 'rejected',
+     *   notes: 'Customer context was missing',
+     * });
+     * ```
+     */
+    async verify(claimId, options) {
+        return (0, client_1.apiRequestWithData)(`/claims/${claimId}/verify`, {
+            method: 'POST',
+            body: options,
+        });
+    },
+    /**
+     * Get facts vs inferences summary
+     *
+     * @example
+     * ```typescript
+     * // Summary for a specific run
+     * const summary = await claims.summary({ runId: 'run_abc123' });
+     *
+     * // Summary for multiple analyses
+     * const summary = await claims.summary({
+     *   analysisIds: ['analysis_1', 'analysis_2'],
+     * });
+     * ```
+     */
+    async summary(options = {}) {
+        const params = new URLSearchParams();
+        if (options.runId)
+            params.set('runId', options.runId);
+        if (options.analysisIds)
+            params.set('analysisIds', options.analysisIds.join(','));
+        return (0, client_1.apiRequestWithData)(`/claims/summary?${params.toString()}`);
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Check if a claim is a fact (observed)
+ */
+function isFact(claim) {
+    return claim.claimType === 'observed';
+}
+/**
+ * Check if a claim is an inference
+ */
+function isInference(claim) {
+    return claim.claimType === 'inferred';
+}
+/**
+ * Check if a claim is computed
+ */
+function isComputed(claim) {
+    return claim.claimType === 'computed';
+}
+/**
+ * Get high confidence claims (>= threshold)
+ */
+function getHighConfidenceClaims(claimsList, threshold = 0.8) {
+    return claimsList.filter((c) => c.confidence >= threshold);
+}
+/**
+ * Group claims by type
+ */
+function groupClaimsByType(claimsList) {
+    return {
+        observed: claimsList.filter((c) => c.claimType === 'observed'),
+        inferred: claimsList.filter((c) => c.claimType === 'inferred'),
+        computed: claimsList.filter((c) => c.claimType === 'computed'),
+    };
+}
+/**
+ * Group claims by category
+ */
+function groupClaimsByCategory(claimsList) {
+    const groups = {
+        outcome: [],
+        root_cause: [],
+        customer_impact: [],
+        churn_risk: [],
+        revenue_impact: [],
+        quality: [],
+        other: [],
+    };
+    for (const claim of claimsList) {
+        groups[claim.claimCategory].push(claim);
+    }
+    return groups;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"claims.js","sourceRoot":"","sources":["../../src/api/claims.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Claims API\n *\n * Facts vs Inferences API for accessing analysis claims\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\nimport type {\n  Claim,\n  ClaimType,\n  ClaimCategory,\n  AnalysisResult,\n  ApiResponse,\n  PaginatedResponse,\n  EvidenceReference,\n} from '../core/types';\n\n// ============================================================================\n// CLAIMS API CLIENT\n// ============================================================================\n\n/**\n * List claims query options\n */\nexport interface ListClaimsOptions {\n  runId?: string;\n  analysisId?: string;\n  claimType?: ClaimType;\n  claimCategory?: ClaimCategory;\n  minConfidence?: number;\n  humanVerified?: boolean;\n  limit?: number;\n  offset?: number;\n}\n\n/**\n * Create analysis options\n */\nexport interface CreateAnalysisOptions {\n  runId: string;\n  modelUsed?: string;\n  outcomeVerdict: 'success' | 'partial_success' | 'failure';\n  outcomeConfidence?: number;\n  rootCauseCategory?: string;\n  rootCauseConfidence?: number;\n  claims?: CreateClaimInput[];\n}\n\nexport interface CreateClaimInput {\n  claimType: ClaimType;\n  claimCategory: ClaimCategory;\n  claimText: string;\n  confidence: number;\n  confidenceCalibration?: 'calibrated' | 'uncalibrated' | 'needs_more_data';\n  evidence?: EvidenceReference[];\n  isExplainable?: boolean;\n  probabilityValue?: number;\n}\n\n/**\n * Facts vs inferences summary\n */\nexport interface FactsVsInferencesSummary {\n  analysisIds: string[];\n  totalClaims: number;\n  observed: {\n    count: number;\n    avgConfidence: number;\n    categories: Record<string, number>;\n  };\n  inferred: {\n    count: number;\n    avgConfidence: number;\n    categories: Record<string, number>;\n  };\n  computed: {\n    count: number;\n    avgConfidence: number;\n    categories: Record<string, number>;\n  };\n  humanVerifiedCount: number;\n  humanRejectedCount: number;\n}\n\n/**\n * Claims API client for facts vs inferences management\n */\nexport const claims = {\n  /**\n   * Create a new analysis for a run\n   *\n   * @example\n   * ```typescript\n   * const analysis = await claims.createAnalysis({\n   *   runId: 'run_abc123',\n   *   outcomeVerdict: 'failure',\n   *   outcomeConfidence: 0.85,\n   *   rootCauseCategory: 'retrieval_failure',\n   *   claims: [\n   *     {\n   *       claimType: 'observed',\n   *       claimCategory: 'root_cause',\n   *       claimText: 'Vector search returned 0 results',\n   *       confidence: 1.0,\n   *       evidence: [{ type: 'span', referenceId: 'span_123', relevance: 'direct', confidence: 1.0 }],\n   *     },\n   *     {\n   *       claimType: 'inferred',\n   *       claimCategory: 'churn_risk',\n   *       claimText: 'High churn risk due to repeated failures',\n   *       confidence: 0.7,\n   *     },\n   *   ],\n   * });\n   * ```\n   */\n  async createAnalysis(options: CreateAnalysisOptions): Promise<AnalysisResult> {\n    return apiRequestWithData<AnalysisResult>('/analyses', {\n      method: 'POST',\n      body: options,\n    });\n  },\n\n  /**\n   * Get an analysis by ID\n   *\n   * @example\n   * ```typescript\n   * const analysis = await claims.getAnalysis('analysis_abc123');\n   * ```\n   */\n  async getAnalysis(analysisId: string): Promise<AnalysisResult> {\n    return apiRequestWithData<AnalysisResult>(`/analyses/${analysisId}`);\n  },\n\n  /**\n   * Get current analysis for a run\n   *\n   * @example\n   * ```typescript\n   * const analysis = await claims.getRunAnalysis('run_abc123');\n   * ```\n   */\n  async getRunAnalysis(runId: string): Promise<AnalysisResult> {\n    return apiRequestWithData<AnalysisResult>(`/runs/${runId}/analysis`);\n  },\n\n  /**\n   * Get analysis history for a run\n   *\n   * @example\n   * ```typescript\n   * const history = await claims.getAnalysisHistory('run_abc123');\n   * ```\n   */\n  async getAnalysisHistory(runId: string): Promise<{\n    runId: string;\n    analyses: Array<{\n      id: string;\n      analysisVersion: string;\n      modelUsed: string;\n      outcomeVerdict: string;\n      isCurrent: boolean;\n      supersededBy?: string;\n      supersessionReason?: string;\n      analyzedAt: string;\n    }>;\n  }> {\n    return apiRequestWithData(`/runs/${runId}/analyses`);\n  },\n\n  /**\n   * Supersede an analysis with a new one\n   *\n   * @example\n   * ```typescript\n   * const newAnalysis = await claims.supersedeAnalysis('analysis_old', {\n   *   reason: 'Improved model accuracy',\n   *   newAnalysis: {\n   *     outcomeVerdict: 'success',\n   *     outcomeConfidence: 0.95,\n   *     claims: [...],\n   *   },\n   * });\n   * ```\n   */\n  async supersedeAnalysis(\n    analysisId: string,\n    options: {\n      reason: string;\n      newAnalysis: Omit<CreateAnalysisOptions, 'runId'>;\n    }\n  ): Promise<{ supersededAnalysisId: string; newAnalysis: AnalysisResult }> {\n    return apiRequestWithData(`/analyses/${analysisId}/supersede`, {\n      method: 'POST',\n      body: options,\n    });\n  },\n\n  /**\n   * List claims with filters\n   *\n   * @example\n   * ```typescript\n   * // Get all inferred claims with high confidence\n   * const { claims } = await claims.list({\n   *   claimType: 'inferred',\n   *   minConfidence: 0.8,\n   * });\n   *\n   * // Get all churn risk claims for a run\n   * const { claims } = await claims.list({\n   *   runId: 'run_abc123',\n   *   claimCategory: 'churn_risk',\n   * });\n   * ```\n   */\n  async list(\n    options: ListClaimsOptions = {}\n  ): Promise<{ claims: Claim[]; limit: number; offset: number; hasMore: boolean }> {\n    const params = new URLSearchParams();\n    if (options.runId) params.set('runId', options.runId);\n    if (options.analysisId) params.set('analysisId', options.analysisId);\n    if (options.claimType) params.set('claimType', options.claimType);\n    if (options.claimCategory) params.set('claimCategory', options.claimCategory);\n    if (options.minConfidence !== undefined) {\n      params.set('minConfidence', String(options.minConfidence));\n    }\n    if (options.humanVerified !== undefined) {\n      params.set('humanVerified', String(options.humanVerified));\n    }\n    if (options.limit) params.set('limit', String(options.limit));\n    if (options.offset) params.set('offset', String(options.offset));\n\n    const response = await apiRequest<ApiResponse<{ claims: Claim[]; limit: number; offset: number; hasMore: boolean }>>(\n      `/claims?${params.toString()}`\n    );\n    return response.data!;\n  },\n\n  /**\n   * Get a claim by ID\n   *\n   * @example\n   * ```typescript\n   * const claim = await claims.get('claim_abc123');\n   * ```\n   */\n  async get(claimId: string): Promise<Claim> {\n    return apiRequestWithData<Claim>(`/claims/${claimId}`);\n  },\n\n  /**\n   * Verify or reject a claim (human feedback)\n   *\n   * @example\n   * ```typescript\n   * // Confirm a claim\n   * await claims.verify('claim_abc123', {\n   *   verdict: 'confirmed',\n   *   notes: 'Verified against ticket history',\n   * });\n   *\n   * // Reject a claim\n   * await claims.verify('claim_abc123', {\n   *   verdict: 'rejected',\n   *   notes: 'Customer context was missing',\n   * });\n   * ```\n   */\n  async verify(\n    claimId: string,\n    options: {\n      verdict: 'confirmed' | 'rejected' | 'modified';\n      notes?: string;\n      modifiedText?: string;\n    }\n  ): Promise<{ claimId: string; verdict: string; message: string }> {\n    return apiRequestWithData(`/claims/${claimId}/verify`, {\n      method: 'POST',\n      body: options,\n    });\n  },\n\n  /**\n   * Get facts vs inferences summary\n   *\n   * @example\n   * ```typescript\n   * // Summary for a specific run\n   * const summary = await claims.summary({ runId: 'run_abc123' });\n   *\n   * // Summary for multiple analyses\n   * const summary = await claims.summary({\n   *   analysisIds: ['analysis_1', 'analysis_2'],\n   * });\n   * ```\n   */\n  async summary(\n    options: { runId?: string; analysisIds?: string[] } = {}\n  ): Promise<FactsVsInferencesSummary> {\n    const params = new URLSearchParams();\n    if (options.runId) params.set('runId', options.runId);\n    if (options.analysisIds) params.set('analysisIds', options.analysisIds.join(','));\n\n    return apiRequestWithData<FactsVsInferencesSummary>(\n      `/claims/summary?${params.toString()}`\n    );\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Check if a claim is a fact (observed)\n */\nexport function isFact(claim: Claim): boolean {\n  return claim.claimType === 'observed';\n}\n\n/**\n * Check if a claim is an inference\n */\nexport function isInference(claim: Claim): boolean {\n  return claim.claimType === 'inferred';\n}\n\n/**\n * Check if a claim is computed\n */\nexport function isComputed(claim: Claim): boolean {\n  return claim.claimType === 'computed';\n}\n\n/**\n * Get high confidence claims (>= threshold)\n */\nexport function getHighConfidenceClaims(\n  claimsList: Claim[],\n  threshold: number = 0.8\n): Claim[] {\n  return claimsList.filter((c) => c.confidence >= threshold);\n}\n\n/**\n * Group claims by type\n */\nexport function groupClaimsByType(\n  claimsList: Claim[]\n): Record<ClaimType, Claim[]> {\n  return {\n    observed: claimsList.filter((c) => c.claimType === 'observed'),\n    inferred: claimsList.filter((c) => c.claimType === 'inferred'),\n    computed: claimsList.filter((c) => c.claimType === 'computed'),\n  };\n}\n\n/**\n * Group claims by category\n */\nexport function groupClaimsByCategory(\n  claimsList: Claim[]\n): Record<ClaimCategory, Claim[]> {\n  const groups: Record<ClaimCategory, Claim[]> = {\n    outcome: [],\n    root_cause: [],\n    customer_impact: [],\n    churn_risk: [],\n    revenue_impact: [],\n    quality: [],\n    other: [],\n  };\n\n  for (const claim of claimsList) {\n    groups[claim.claimCategory].push(claim);\n  }\n\n  return groups;\n}\n"]}