@thinkhive/sdk 3.1.1 → 4.0.0

package/dist/api/eval-health.js

@@ -0,0 +1,224 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Evaluation Health API
+ *
+ * API for eval saturation monitoring, regression detection, and health reports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalHealth = void 0;
+exports.hasHealthIssue = hasHealthIssue;
+exports.getSeverityLevel = getSeverityLevel;
+exports.isSaturated = isSaturated;
+exports.getSaturationRecommendation = getSaturationRecommendation;
+const client_1 = require("../core/client");
+// ============================================================================
+// EVAL HEALTH API CLIENT
+// ============================================================================
+/**
+ * Evaluation Health API client for monitoring eval quality and detecting regressions
+ */
+exports.evalHealth = {
+    /**
+     * Get comprehensive health report for an agent
+     *
+     * @example
+     * ```typescript
+     * const report = await evalHealth.getReport('agent_123');
+     * console.log(`Overall health: ${report.overallHealth}`);
+     * console.log(`Active regressions: ${report.regressionCount}`);
+     * ```
+     */
+    async getReport(agentId) {
+        return (0, client_1.apiRequestWithData)(`/eval-health/report?agentId=${agentId}`, { apiVersion: 'none' });
+    },
+    // ---------------------------------------------------------------------------
+    // SNAPSHOTS
+    // ---------------------------------------------------------------------------
+    /**
+     * Get historical health snapshots
+     *
+     * @example
+     * ```typescript
+     * const snapshots = await evalHealth.getSnapshots({
+     *   agentId: 'agent_123',
+     *   startDate: '2024-01-01T00:00:00Z',
+     *   endDate: '2024-01-31T23:59:59Z',
+     * });
+     * ```
+     */
+    async getSnapshots(options) {
+        const params = new URLSearchParams();
+        params.set('agentId', options.agentId);
+        if (options.criterionId)
+            params.set('criterionId', options.criterionId);
+        if (options.startDate)
+            params.set('startDate', options.startDate);
+        if (options.endDate)
+            params.set('endDate', options.endDate);
+        return (0, client_1.apiRequestWithData)(`/eval-health/snapshots?${params.toString()}`, { apiVersion: 'none' });
+    },
+    /**
+     * Get latest health snapshot
+     *
+     * @example
+     * ```typescript
+     * const snapshot = await evalHealth.getLatestSnapshot('agent_123');
+     * ```
+     */
+    async getLatestSnapshot(agentId, criterionId) {
+        const params = new URLSearchParams();
+        params.set('agentId', agentId);
+        if (criterionId)
+            params.set('criterionId', criterionId);
+        return (0, client_1.apiRequestWithData)(`/eval-health/snapshots/latest?${params.toString()}`, { apiVersion: 'none' });
+    },
+    /**
+     * Record a health snapshot
+     *
+     * @example
+     * ```typescript
+     * const snapshot = await evalHealth.recordSnapshot({
+     *   agentId: 'agent_123',
+     *   snapshotDate: new Date().toISOString(),
+     *   passRate: '0.85',
+     *   evalCount: 150,
+     *   healthStatus: 'healthy',
+     * });
+     * ```
+     */
+    async recordSnapshot(options) {
+        return (0, client_1.apiRequestWithData)('/eval-health/snapshots', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'none',
+        });
+    },
+    // ---------------------------------------------------------------------------
+    // REGRESSIONS
+    // ---------------------------------------------------------------------------
+    /**
+     * Get unresolved regressions for an agent
+     *
+     * @example
+     * ```typescript
+     * const regressions = await evalHealth.getRegressions('agent_123');
+     * for (const regression of regressions) {
+     *   console.log(`${regression.severity}: ${regression.delta}% drop`);
+     * }
+     * ```
+     */
+    async getRegressions(agentId) {
+        return (0, client_1.apiRequestWithData)(`/eval-health/regressions?agentId=${agentId}`, { apiVersion: 'none' });
+    },
+    /**
+     * Record a new regression
+     *
+     * @example
+     * ```typescript
+     * const regression = await evalHealth.recordRegression({
+     *   agentId: 'agent_123',
+     *   severity: 'moderate',
+     *   baselinePassRate: '0.92',
+     *   currentPassRate: '0.78',
+     *   delta: '-0.14',
+     *   baselinePeriodStart: '2024-01-01T00:00:00Z',
+     *   baselinePeriodEnd: '2024-01-15T23:59:59Z',
+     *   currentPeriodStart: '2024-01-16T00:00:00Z',
+     *   currentPeriodEnd: '2024-01-31T23:59:59Z',
+     * });
+     * ```
+     */
+    async recordRegression(options) {
+        return (0, client_1.apiRequestWithData)('/eval-health/regressions', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Resolve a regression
+     *
+     * @example
+     * ```typescript
+     * await evalHealth.resolveRegression('regression_123', {
+     *   resolutionType: 'fixed',
+     *   notes: 'Updated prompt template to address quality issues',
+     * });
+     * ```
+     */
+    async resolveRegression(regressionId, options) {
+        await (0, client_1.apiRequest)(`/eval-health/regressions/${regressionId}/resolve`, {
+            method: 'POST',
+            body: options,
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Acknowledge a regression
+     *
+     * @example
+     * ```typescript
+     * await evalHealth.acknowledgeRegression('regression_123');
+     * ```
+     */
+    async acknowledgeRegression(regressionId) {
+        await (0, client_1.apiRequest)(`/eval-health/regressions/${regressionId}/acknowledge`, {
+            method: 'POST',
+            apiVersion: 'none',
+        });
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Check if health status indicates an issue
+ *
+ * @param status - Health status to check
+ * @returns Whether the status indicates a problem
+ */
+function hasHealthIssue(status) {
+    return status === 'warning' || status === 'critical';
+}
+/**
+ * Get severity level as numeric value for sorting
+ *
+ * @param severity - Regression severity
+ * @returns Numeric severity (1-3, higher is worse)
+ */
+function getSeverityLevel(severity) {
+    switch (severity) {
+        case 'minor': return 1;
+        case 'moderate': return 2;
+        case 'severe': return 3;
+        default: return 0;
+    }
+}
+/**
+ * Check if evaluation is saturated
+ *
+ * @param snapshot - Health snapshot to check
+ * @returns Whether evaluation is at ceiling or floor
+ */
+function isSaturated(snapshot) {
+    return snapshot.saturationType === 'ceiling' || snapshot.saturationType === 'floor';
+}
+/**
+ * Get recommendation for saturation type
+ *
+ * @param saturationType - Type of saturation
+ * @returns Recommendation string
+ */
+function getSaturationRecommendation(saturationType) {
+    switch (saturationType) {
+        case 'ceiling':
+            return 'Evaluation criteria may be too lenient. Consider adding stricter checks or more challenging test cases.';
+        case 'floor':
+            return 'Evaluation criteria may be too strict. Consider relaxing thresholds or reviewing criteria for accuracy.';
+        case 'healthy':
+            return 'Evaluation is operating within healthy parameters.';
+        default:
+            return 'Unable to determine saturation status.';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eval-health.js","sourceRoot":"","sources":["../../src/api/eval-health.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Evaluation Health API\n *\n * API for eval saturation monitoring, regression detection, and health reports\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport type SaturationType = 'ceiling' | 'floor' | 'healthy';\nexport type HealthStatus = 'healthy' | 'warning' | 'critical';\nexport type RegressionSeverity = 'minor' | 'moderate' | 'severe';\n\nexport interface EvalHealthSnapshot {\n  id: string;\n  companyId: string;\n  agentId: string;\n  criterionId?: string;\n  snapshotDate: string;\n  passRate?: string;\n  evalCount?: number;\n  meanScore?: string;\n  saturationType?: SaturationType;\n  daysAtSaturation?: number;\n  trendDirection?: string;\n  trendStrength?: string;\n  healthStatus?: HealthStatus;\n  healthScore?: string;\n  createdAt: string;\n}\n\nexport interface EvalRegression {\n  id: string;\n  companyId: string;\n  agentId: string;\n  criterionId?: string;\n  severity: RegressionSeverity;\n  baselinePassRate: string;\n  currentPassRate: string;\n  delta: string;\n  deltaPercent?: string;\n  baselinePeriodStart: string;\n  baselinePeriodEnd: string;\n  currentPeriodStart: string;\n  currentPeriodEnd: string;\n  baselineEvalCount?: number;\n  currentEvalCount?: number;\n  suspectedCauses?: unknown[];\n  isSignificant?: boolean;\n  isResolved: boolean;\n  isAcknowledged: boolean;\n  resolvedAt?: string;\n  resolvedBy?: string;\n  resolutionType?: string;\n  resolutionNotes?: string;\n  acknowledgedAt?: string;\n  acknowledgedBy?: string;\n  detectedAt: string;\n  createdAt: string;\n}\n\nexport interface HealthReport {\n  agentId: string;\n  generatedAt: string;\n  overallHealth: HealthStatus;\n  overallScore: number;\n  passRate: number;\n  evalCount: number;\n  saturationStatus: {\n    type: SaturationType;\n    daysAtSaturation: number;\n    recommendation: string;\n  };\n  regressionCount: number;\n  activeRegressions: EvalRegression[];\n  trend: {\n    direction: 'improving' | 'stable' | 'declining';\n    strength: number;\n    description: string;\n  };\n  recommendations: string[];\n}\n\nexport interface CreateSnapshotOptions {\n  agentId: string;\n  criterionId?: string;\n  snapshotDate: string;\n  passRate?: string;\n  evalCount?: number;\n  meanScore?: string;\n  saturationType?: SaturationType;\n  daysAtSaturation?: number;\n  trendDirection?: string;\n  trendStrength?: string;\n  healthStatus?: HealthStatus;\n  healthScore?: string;\n}\n\nexport interface CreateRegressionOptions {\n  agentId: string;\n  criterionId?: string;\n  severity: RegressionSeverity;\n  baselinePassRate: string;\n  currentPassRate: string;\n  delta: string;\n  deltaPercent?: string;\n  baselinePeriodStart: string;\n  baselinePeriodEnd: string;\n  currentPeriodStart: string;\n  currentPeriodEnd: string;\n  baselineEvalCount?: number;\n  currentEvalCount?: number;\n  suspectedCauses?: unknown[];\n  isSignificant?: boolean;\n  detectedAt?: string;\n}\n\nexport interface ResolveRegressionOptions {\n  resolutionType: string;\n  notes?: string;\n}\n\nexport interface GetSnapshotsOptions {\n  agentId: string;\n  criterionId?: string;\n  startDate?: string;\n  endDate?: string;\n}\n\n// ============================================================================\n// EVAL HEALTH API CLIENT\n// ============================================================================\n\n/**\n * Evaluation Health API client for monitoring eval quality and detecting regressions\n */\nexport const evalHealth = {\n  /**\n   * Get comprehensive health report for an agent\n   *\n   * @example\n   * ```typescript\n   * const report = await evalHealth.getReport('agent_123');\n   * console.log(`Overall health: ${report.overallHealth}`);\n   * console.log(`Active regressions: ${report.regressionCount}`);\n   * ```\n   */\n  async getReport(agentId: string): Promise<HealthReport> {\n    return apiRequestWithData<HealthReport>(\n      `/eval-health/report?agentId=${agentId}`,\n      { apiVersion: 'none' }\n    );\n  },\n\n  // ---------------------------------------------------------------------------\n  // SNAPSHOTS\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Get historical health snapshots\n   *\n   * @example\n   * ```typescript\n   * const snapshots = await evalHealth.getSnapshots({\n   *   agentId: 'agent_123',\n   *   startDate: '2024-01-01T00:00:00Z',\n   *   endDate: '2024-01-31T23:59:59Z',\n   * });\n   * ```\n   */\n  async getSnapshots(options: GetSnapshotsOptions): Promise<EvalHealthSnapshot[]> {\n    const params = new URLSearchParams();\n    params.set('agentId', options.agentId);\n    if (options.criterionId) params.set('criterionId', options.criterionId);\n    if (options.startDate) params.set('startDate', options.startDate);\n    if (options.endDate) params.set('endDate', options.endDate);\n\n    return apiRequestWithData<EvalHealthSnapshot[]>(\n      `/eval-health/snapshots?${params.toString()}`,\n      { apiVersion: 'none' }\n    );\n  },\n\n  /**\n   * Get latest health snapshot\n   *\n   * @example\n   * ```typescript\n   * const snapshot = await evalHealth.getLatestSnapshot('agent_123');\n   * ```\n   */\n  async getLatestSnapshot(agentId: string, criterionId?: string): Promise<EvalHealthSnapshot | null> {\n    const params = new URLSearchParams();\n    params.set('agentId', agentId);\n    if (criterionId) params.set('criterionId', criterionId);\n\n    return apiRequestWithData<EvalHealthSnapshot | null>(\n      `/eval-health/snapshots/latest?${params.toString()}`,\n      { apiVersion: 'none' }\n    );\n  },\n\n  /**\n   * Record a health snapshot\n   *\n   * @example\n   * ```typescript\n   * const snapshot = await evalHealth.recordSnapshot({\n   *   agentId: 'agent_123',\n   *   snapshotDate: new Date().toISOString(),\n   *   passRate: '0.85',\n   *   evalCount: 150,\n   *   healthStatus: 'healthy',\n   * });\n   * ```\n   */\n  async recordSnapshot(options: CreateSnapshotOptions): Promise<EvalHealthSnapshot> {\n    return apiRequestWithData<EvalHealthSnapshot>('/eval-health/snapshots', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'none',\n    });\n  },\n\n  // ---------------------------------------------------------------------------\n  // REGRESSIONS\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Get unresolved regressions for an agent\n   *\n   * @example\n   * ```typescript\n   * const regressions = await evalHealth.getRegressions('agent_123');\n   * for (const regression of regressions) {\n   *   console.log(`${regression.severity}: ${regression.delta}% drop`);\n   * }\n   * ```\n   */\n  async getRegressions(agentId: string): Promise<EvalRegression[]> {\n    return apiRequestWithData<EvalRegression[]>(\n      `/eval-health/regressions?agentId=${agentId}`,\n      { apiVersion: 'none' }\n    );\n  },\n\n  /**\n   * Record a new regression\n   *\n   * @example\n   * ```typescript\n   * const regression = await evalHealth.recordRegression({\n   *   agentId: 'agent_123',\n   *   severity: 'moderate',\n   *   baselinePassRate: '0.92',\n   *   currentPassRate: '0.78',\n   *   delta: '-0.14',\n   *   baselinePeriodStart: '2024-01-01T00:00:00Z',\n   *   baselinePeriodEnd: '2024-01-15T23:59:59Z',\n   *   currentPeriodStart: '2024-01-16T00:00:00Z',\n   *   currentPeriodEnd: '2024-01-31T23:59:59Z',\n   * });\n   * ```\n   */\n  async recordRegression(options: CreateRegressionOptions): Promise<EvalRegression> {\n    return apiRequestWithData<EvalRegression>('/eval-health/regressions', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'none',\n    });\n  },\n\n  /**\n   * Resolve a regression\n   *\n   * @example\n   * ```typescript\n   * await evalHealth.resolveRegression('regression_123', {\n   *   resolutionType: 'fixed',\n   *   notes: 'Updated prompt template to address quality issues',\n   * });\n   * ```\n   */\n  async resolveRegression(regressionId: string, options: ResolveRegressionOptions): Promise<void> {\n    await apiRequest(`/eval-health/regressions/${regressionId}/resolve`, {\n      method: 'POST',\n      body: options,\n      apiVersion: 'none',\n    });\n  },\n\n  /**\n   * Acknowledge a regression\n   *\n   * @example\n   * ```typescript\n   * await evalHealth.acknowledgeRegression('regression_123');\n   * ```\n   */\n  async acknowledgeRegression(regressionId: string): Promise<void> {\n    await apiRequest(`/eval-health/regressions/${regressionId}/acknowledge`, {\n      method: 'POST',\n      apiVersion: 'none',\n    });\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Check if health status indicates an issue\n *\n * @param status - Health status to check\n * @returns Whether the status indicates a problem\n */\nexport function hasHealthIssue(status: HealthStatus): boolean {\n  return status === 'warning' || status === 'critical';\n}\n\n/**\n * Get severity level as numeric value for sorting\n *\n * @param severity - Regression severity\n * @returns Numeric severity (1-3, higher is worse)\n */\nexport function getSeverityLevel(severity: RegressionSeverity): number {\n  switch (severity) {\n    case 'minor': return 1;\n    case 'moderate': return 2;\n    case 'severe': return 3;\n    default: return 0;\n  }\n}\n\n/**\n * Check if evaluation is saturated\n *\n * @param snapshot - Health snapshot to check\n * @returns Whether evaluation is at ceiling or floor\n */\nexport function isSaturated(snapshot: EvalHealthSnapshot): boolean {\n  return snapshot.saturationType === 'ceiling' || snapshot.saturationType === 'floor';\n}\n\n/**\n * Get recommendation for saturation type\n *\n * @param saturationType - Type of saturation\n * @returns Recommendation string\n */\nexport function getSaturationRecommendation(saturationType: SaturationType): string {\n  switch (saturationType) {\n    case 'ceiling':\n      return 'Evaluation criteria may be too lenient. Consider adding stricter checks or more challenging test cases.';\n    case 'floor':\n      return 'Evaluation criteria may be too strict. Consider relaxing thresholds or reviewing criteria for accuracy.';\n    case 'healthy':\n      return 'Evaluation is operating within healthy parameters.';\n    default:\n      return 'Unable to determine saturation status.';\n  }\n}\n"]}

package/dist/api/human-review.d.ts

@@ -0,0 +1,275 @@
+/**
+ * ThinkHive SDK v3.0 - Human Review API
+ *
+ * API for managing human review queue, calibration sets, and reviewer management
+ */
+export type HumanReviewStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'expired';
+export type HumanReviewType = 'disagreement' | 'low_confidence' | 'calibration' | 'random_sample' | 'flagged';
+export interface HumanReviewQueueItem {
+    id: string;
+    companyId: string;
+    agentId: string;
+    traceId: string;
+    criterionId?: string;
+    reviewType: HumanReviewType;
+    priority: number;
+    status: HumanReviewStatus;
+    llmScore?: number;
+    llmPassed?: boolean;
+    llmReasoning?: string;
+    llmConfidence?: number;
+    reviewerId?: string;
+    humanScore?: number;
+    humanPassed?: boolean;
+    humanReasoning?: string;
+    reviewDurationMs?: number;
+    isCalibrationSample?: boolean;
+    calibrationSetId?: string;
+    expectedScore?: number;
+    expectedPassed?: boolean;
+    expiresAt?: string;
+    claimedAt?: string;
+    completedAt?: string;
+    createdAt: string;
+}
+export interface AddToQueueOptions {
+    traceId: string;
+    criterionId?: string;
+    agentId: string;
+    reviewType: HumanReviewType;
+    priority?: number;
+    llmScore?: number;
+    llmPassed?: boolean;
+    llmReasoning?: string;
+    llmConfidence?: number;
+    isCalibrationSample?: boolean;
+    calibrationSetId?: string;
+    expectedScore?: number;
+    expectedPassed?: boolean;
+    expiresInMs?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface SubmitReviewOptions {
+    passed: boolean;
+    score: number;
+    reasoning: string;
+    durationMs: number;
+}
+export interface CalibrationSet {
+    id: string;
+    companyId: string;
+    agentId?: string;
+    name: string;
+    description?: string;
+    targetSampleCount: number;
+    currentSampleCount: number;
+    minAgreementRate: number;
+    passingScoreThreshold: number;
+    criteriaIds: string[];
+    isActive: boolean;
+    createdBy?: string;
+    createdAt: string;
+}
+export interface CreateCalibrationSetOptions {
+    name: string;
+    description?: string;
+    agentId: string;
+    criterionId?: string;
+    targetAgreement?: number;
+    minSamples?: number;
+}
+export interface ReviewerCalibration {
+    id: string;
+    userId: string;
+    calibrationSetId: string;
+    totalReviews: number;
+    agreementRate: number;
+    meanAbsoluteError: number;
+    isCertified: boolean;
+    certifiedAt?: string;
+    lastReviewAt?: string;
+}
+export interface QueueStats {
+    pending: number;
+    inProgress: number;
+    completed: number;
+    skipped: number;
+    expired: number;
+    avgReviewDurationMs?: number;
+    avgAgreementRate?: number;
+}
+export interface ListQueueOptions {
+    agentId?: string;
+    status?: HumanReviewStatus;
+    reviewType?: HumanReviewType;
+    isCalibration?: boolean;
+    minPriority?: number;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Human Review API client for managing human review queue and calibration
+ */
+export declare const humanReview: {
+    /**
+     * Get pending review queue items
+     *
+     * @example
+     * ```typescript
+     * const items = await humanReview.getQueue({
+     *   agentId: 'agent_123',
+     *   status: 'pending',
+     *   limit: 20,
+     * });
+     * ```
+     */
+    getQueue(options?: ListQueueOptions): Promise<HumanReviewQueueItem[]>;
+    /**
+     * Add an item to the review queue
+     *
+     * @example
+     * ```typescript
+     * const item = await humanReview.addToQueue({
+     *   traceId: 'trace_123',
+     *   agentId: 'agent_123',
+     *   reviewType: 'disagreement',
+     *   priority: 80,
+     *   llmScore: 65,
+     *   llmPassed: true,
+     * });
+     * ```
+     */
+    addToQueue(options: AddToQueueOptions): Promise<HumanReviewQueueItem>;
+    /**
+     * Get a specific review item
+     *
+     * @example
+     * ```typescript
+     * const item = await humanReview.getItem('item_123');
+     * ```
+     */
+    getItem(itemId: string): Promise<HumanReviewQueueItem>;
+    /**
+     * Claim a review item for processing
+     *
+     * @example
+     * ```typescript
+     * const item = await humanReview.claim('item_123');
+     * ```
+     */
+    claim(itemId: string): Promise<HumanReviewQueueItem>;
+    /**
+     * Release a claimed review item
+     *
+     * @example
+     * ```typescript
+     * await humanReview.release('item_123');
+     * ```
+     */
+    release(itemId: string): Promise<HumanReviewQueueItem>;
+    /**
+     * Skip a review item
+     *
+     * @example
+     * ```typescript
+     * await humanReview.skip('item_123');
+     * ```
+     */
+    skip(itemId: string): Promise<HumanReviewQueueItem>;
+    /**
+     * Submit a review
+     *
+     * @example
+     * ```typescript
+     * const result = await humanReview.submit('item_123', {
+     *   passed: true,
+     *   score: 85,
+     *   reasoning: 'Response accurately addressed the query',
+     *   durationMs: 45000,
+     * });
+     * ```
+     */
+    submit(itemId: string, review: SubmitReviewOptions): Promise<HumanReviewQueueItem>;
+    /**
+     * Get queue statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = await humanReview.getStats('agent_123');
+     * ```
+     */
+    getStats(agentId?: string): Promise<QueueStats>;
+    /**
+     * Get next item for a reviewer
+     *
+     * @example
+     * ```typescript
+     * const nextItem = await humanReview.getNextItem('agent_123');
+     * ```
+     */
+    getNextItem(agentId?: string): Promise<HumanReviewQueueItem | null>;
+    /**
+     * Get available review types
+     *
+     * @example
+     * ```typescript
+     * const types = await humanReview.getReviewTypes();
+     * ```
+     */
+    getReviewTypes(): Promise<Array<{
+        id: string;
+        name: string;
+        description: string;
+        autoTrigger: boolean;
+    }>>;
+    /**
+     * Get calibration sets
+     *
+     * @example
+     * ```typescript
+     * const sets = await humanReview.getCalibrationSets('agent_123');
+     * ```
+     */
+    getCalibrationSets(agentId?: string): Promise<CalibrationSet[]>;
+    /**
+     * Create a calibration set
+     *
+     * @example
+     * ```typescript
+     * const set = await humanReview.createCalibrationSet({
+     *   name: 'Quality Calibration Q1',
+     *   agentId: 'agent_123',
+     *   targetAgreement: 0.85,
+     *   minSamples: 50,
+     * });
+     * ```
+     */
+    createCalibrationSet(options: CreateCalibrationSetOptions): Promise<CalibrationSet>;
+    /**
+     * Get a calibration set by ID
+     *
+     * @example
+     * ```typescript
+     * const set = await humanReview.getCalibrationSet('set_123');
+     * ```
+     */
+    getCalibrationSet(setId: string): Promise<CalibrationSet>;
+    /**
+     * Get certified reviewers for a calibration set
+     *
+     * @example
+     * ```typescript
+     * const reviewers = await humanReview.getCertifiedReviewers('set_123');
+     * ```
+     */
+    getCertifiedReviewers(calibrationSetId: string): Promise<ReviewerCalibration[]>;
+    /**
+     * Get reviewer calibration status
+     *
+     * @example
+     * ```typescript
+     * const calibrations = await humanReview.getReviewerCalibrations('user_123');
+     * ```
+     */
+    getReviewerCalibrations(userId: string): Promise<ReviewerCalibration[]>;
+};