@chanl-ai/sdk 2.0.1

package/dist/modules/calls.d.ts

@@ -0,0 +1,825 @@
+/**
+ * CallsModule - SDK module for call management
+ *
+ * Provides operations for:
+ * - Importing calls (transcript, audio URL, audio ID, S3)
+ * - Listing and querying calls (including external reference filtering)
+ * - Call analysis and evaluation
+ * - Metrics and transcripts
+ */
+import { ChanlSDK } from '../client';
+import { ApiResponse } from '../types/config';
+import { ToolCall } from '../types/tool-calls';
+/**
+ * Call direction - inbound (customer called), outbound (agent called), or web-based
+ */
+export type CallDirection = 'inbound' | 'outbound' | 'web';
+/**
+ * Call status - current state of the call
+ */
+export type CallStatus = 'queued' | 'ringing' | 'in-progress' | 'forwarding' | 'ended' | 'failed';
+/**
+ * Call origin - whether real call or simulated from scenario
+ */
+export type CallOrigin = 'simulation' | 'real';
+/**
+ * Analysis fields that can be requested during import
+ * When not specified, all fields are analyzed (default behavior)
+ */
+export type AnalysisField = 'followups' | 'sentiment' | 'topics' | 'keywords' | 'coaching' | 'predictions' | 'quality' | 'speakers' | 'upsell' | 'metrics' | 'extraction';
+/**
+ * Extraction field types supported
+ */
+export type ExtractionFieldType = 'string' | 'number' | 'boolean' | 'date';
+/**
+ * Structured transcript segment for import operations
+ * Uses startTime/endTime in milliseconds (differs from Transcript module's start/end)
+ */
+export interface ImportTranscriptSegment {
+    /** Speaker role */
+    speaker: 'agent' | 'customer' | 'unknown';
+    /** Segment text content */
+    text: string;
+    /** Segment start time in milliseconds */
+    startTime?: number;
+    /** Segment end time in milliseconds */
+    endTime?: number;
+}
+/**
+ * Custom extraction field definition
+ * Used to extract business-specific data from call transcripts
+ */
+export interface CustomExtractionField {
+    /** Unique key for this field (used in extractedData.custom response) */
+    key: string;
+    /** Human-readable label for this field */
+    label: string;
+    /** Data type for the extracted value */
+    type: ExtractionFieldType;
+    /** Description of what this field captures (helps LLM accuracy) */
+    description?: string;
+    /** Whether this field is required */
+    required?: boolean;
+    /** Hint for the LLM on how to find/extract this value */
+    promptHint?: string;
+}
+/**
+ * Extracted field value with confidence
+ */
+export interface ExtractedValue {
+    value: string | number | boolean;
+    confidence: number;
+    source?: string;
+}
+/**
+ * Extracted data from call transcript
+ */
+export interface ExtractedData {
+    customerId?: string;
+    customerEmail?: string;
+    customerPhone?: string;
+    orderNumber?: string;
+    accountNumber?: string;
+    custom?: Record<string, ExtractedValue>;
+    extractedAt?: string;
+    templateId?: string;
+}
+/**
+ * Options for importing a call
+ *
+ * Supports four input modes (at least one required):
+ * 1. S3 Import: bucket + region + accessKeyId + secretAccessKey + key
+ * 2. Audio URL: audioUrl (downloaded to storage)
+ * 3. Audio ID: audioId (reference pre-uploaded audio)
+ * 4. Transcript Only: transcript (skips Deepgram)
+ */
+export interface CallImportOptions {
+    /** Pre-existing transcript - raw text or structured segments */
+    transcript?: string | ImportTranscriptSegment[];
+    /** Direct URL to audio file */
+    audioUrl?: string;
+    /** ID of pre-uploaded audio */
+    audioId?: string;
+    /** S3 bucket name */
+    bucket?: string;
+    /** S3 object key */
+    key?: string;
+    /** AWS region (use "auto" for Tigris) */
+    region?: string;
+    /** AWS access key ID */
+    accessKeyId?: string;
+    /** AWS secret access key */
+    secretAccessKey?: string;
+    /** Custom S3 endpoint for S3-compatible services */
+    endpoint?: string;
+    /** Agent ID to associate */
+    agentId?: string;
+    /** Customer name */
+    customerName?: string;
+    /** Customer phone number */
+    customerPhone?: string;
+    /** Agent name */
+    agentName?: string;
+    /** Agent phone number */
+    agentPhone?: string;
+    /** Call direction */
+    callDirection?: 'inbound' | 'outbound';
+    /** When the call started (ISO 8601) */
+    callStartedAt?: string;
+    /** When the call ended (ISO 8601) */
+    callEndedAt?: string;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+    /** Language code for transcription */
+    language?: string;
+    /** Customer-provided external reference IDs */
+    externalReferenceIds?: Record<string, string>;
+    /** Specific analysis fields to include (default: all) */
+    analysisFields?: AnalysisField[];
+    /** Scorecard ID to evaluate against */
+    scorecardId?: string;
+    /** Custom extraction fields (overrides workspace defaults) */
+    customExtractions?: CustomExtractionField[];
+    /** Extraction template ID */
+    extractionTemplateId?: string;
+    /** Skip extraction entirely */
+    skipExtraction?: boolean;
+    /** Webhook URL for analysis completion */
+    webhookUrl?: string;
+    /** Webhook secret for HMAC signature */
+    webhookSecret?: string;
+}
+/**
+ * Response from call import
+ */
+export interface CallImportResponse {
+    /** Call ID (may be empty if created later by processor) */
+    callId: string;
+    /** Audio record ID */
+    audioId: string;
+    /** Storage key */
+    storageKey: string;
+    /** Original S3 key (for S3 imports) */
+    originalKey?: string;
+    /** File size in bytes */
+    fileSize: number;
+    /** Processing status */
+    processingStatus: 'pending' | 'processing' | 'completed' | 'failed';
+    /** Transcript ID (if provided directly) */
+    transcriptId?: string;
+    /** External reference IDs (echoed back) */
+    externalReferenceIds?: Record<string, string>;
+    /** Import mode used */
+    importMode?: 'transcriptOnly' | 'audioUrl' | 'audioId' | 's3';
+}
+/**
+ * Call entity - represents a call record
+ */
+export interface Call {
+    id: string;
+    workspaceId: string;
+    scenarioId?: string;
+    scenarioExecutionId?: string;
+    agentId?: string;
+    personaId?: string;
+    provider: string;
+    providerCallId: string;
+    direction: CallDirection;
+    status: CallStatus;
+    origin: CallOrigin;
+    customerName: string;
+    customerPhone: string;
+    agentName: string;
+    agentPhone?: string;
+    startTime: string;
+    endTime?: string;
+    duration?: number;
+    cost?: number;
+    recordingUrl?: string;
+    transcriptId?: string;
+    audioId?: string;
+    scorecardResultIds?: string[];
+    score?: number;
+    demandsAction?: boolean;
+    externalReferenceIds?: Record<string, string>;
+    analysisStatus?: 'none' | 'pending' | 'processing' | 'completed' | 'failed';
+    analysisFields?: AnalysisField[];
+    summary?: CallSummary;
+    metrics?: CallMetricsData;
+    extractedData?: ExtractedData;
+    metadata?: {
+        escalationNeeded?: boolean;
+        tags?: string[];
+        customData?: Record<string, unknown>;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Call summary - scorecard-independent analysis
+ */
+export interface CallSummary {
+    sentiment?: {
+        beginning: 'positive' | 'neutral' | 'negative';
+        ending: 'positive' | 'neutral' | 'negative';
+        average: number;
+        trend: 'improving' | 'stable' | 'declining';
+    };
+    topics?: string[];
+    keywords?: string[];
+    callSummary?: string;
+    problem?: string;
+    resolution?: string;
+    language?: string;
+    speakers?: {
+        agent: {
+            speakerIndex: number;
+            name?: string;
+            confidence: number;
+        };
+        customer: {
+            speakerIndex: number;
+            name?: string;
+            confidence: number;
+        };
+    };
+    qualityMetrics?: {
+        resolutionConfidence: number;
+        customerEffortScore: number;
+        empathyScore: number;
+        escalationRisk: 'low' | 'medium' | 'high';
+        complianceScore: number;
+        agentConfidence: number;
+        issueComplexity: 'simple' | 'moderate' | 'complex';
+    };
+    predictions?: {
+        firstCallResolution: boolean;
+        callbackProbability: number;
+        customerSatisfactionPrediction: number;
+    };
+    coaching?: {
+        opportunities: string[];
+        knowledgeGaps: string[];
+    };
+    upsellOpportunity?: {
+        detected: boolean;
+        context: string | null;
+    };
+    actionItems?: {
+        agentCommitments: string[];
+        customerActions: string[];
+        followUpRequired: boolean;
+        followUpTimeframe?: string;
+    };
+    computedAt?: string;
+}
+/**
+ * Call metrics data structure
+ */
+export interface CallMetricsData {
+    talkTime: {
+        agent: number;
+        customer: number;
+        total: number;
+        agentRatio: number;
+        customerRatio: number;
+    };
+    responseTime: {
+        agent: number;
+        customer: number;
+        average: number;
+    };
+    silence: {
+        maxDuration: number;
+        total: number;
+        average: number;
+    };
+    interruptions: {
+        agent: number;
+        customer: number;
+        total: number;
+    };
+    duration: number;
+    longestMonologue?: {
+        agent: number;
+        customer: number;
+    };
+    talkSpeed?: {
+        agent: number;
+        customer: number;
+        average: number;
+    };
+    questionCount?: {
+        agent: number;
+        customer: number;
+        total: number;
+    };
+    turnCount?: number;
+}
+/**
+ * Call filters for list operations
+ */
+export interface CallFilters {
+    scenarioId?: string;
+    scenarioExecutionId?: string;
+    agentId?: string;
+    personaId?: string;
+    status?: string;
+    direction?: string;
+    origin?: string;
+    provider?: string;
+    customerName?: string;
+    customerPhone?: string;
+    startDate?: string;
+    endDate?: string;
+    demandsAction?: boolean;
+    /**
+     * External reference filters
+     * Keys map to externalReferenceIds stored on the call
+     * @example { orderId: 'ORDER-123', customerId: 'cust_789' }
+     */
+    externalRefs?: Record<string, string>;
+    page?: number;
+    limit?: number;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+}
+export interface CallListResponse {
+    calls: Call[];
+    pagination?: {
+        total: number;
+        page: number;
+        limit: number;
+        pages: number;
+    };
+}
+export interface CallResponse {
+    call: Call;
+}
+/**
+ * Options for updating a call
+ */
+export interface UpdateCallOptions {
+    /** Call direction */
+    direction?: 'inbound' | 'outbound' | 'web';
+    /** Call status */
+    status?: CallStatus;
+    /** Customer name */
+    customerName?: string;
+    /** Customer phone number */
+    customerPhone?: string;
+    /** Agent name */
+    agentName?: string;
+    /** Agent phone number */
+    agentPhone?: string;
+    /** Agent ID */
+    agentId?: string;
+    /** Call metadata */
+    metadata?: {
+        escalationNeeded?: boolean;
+        tags?: string[];
+        customData?: Record<string, unknown>;
+    };
+}
+/**
+ * Options for bulk deleting calls
+ */
+export interface BulkDeleteOptions {
+    /** Array of call IDs to delete (max 100) */
+    callIds: string[];
+    /** Also delete associated storage files (default: true) */
+    deleteStorageFiles?: boolean;
+}
+/**
+ * Response from bulk delete operation
+ */
+export interface BulkDeleteResponse {
+    success: boolean;
+    deletedCount: number;
+    storageFilesDeleted: number;
+    failedIds?: string[];
+    error?: string;
+}
+export interface AnalyzeCallOptions {
+    scorecardId?: string;
+    forceReanalysis?: boolean;
+    force?: boolean;
+}
+export interface AnalyzeCallResponse {
+    callId: string;
+    resultId?: string;
+    status: 'queued' | 'no_scorecard' | 'no_transcript';
+    message?: string;
+}
+export interface CallScorecardResult {
+    id: string;
+    callId: string;
+    scorecardId: string;
+    overallScore?: number;
+    status?: string;
+    categoryScores?: Array<{
+        categoryId: string;
+        categoryName: string;
+        score: number;
+        weight: number;
+    }>;
+    criteriaResults?: Array<{
+        criterionId: string;
+        criterionName: string;
+        score: number;
+        feedback?: string;
+        evidence?: string;
+    }>;
+    feedback?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CallAnalysisResponse {
+    results: CallScorecardResult[];
+}
+export interface CallMetrics {
+    callId: string;
+    metrics: {
+        talkTime?: {
+            total?: number;
+            agent?: number;
+            customer?: number;
+        };
+        responseTime?: {
+            average?: number;
+            max?: number;
+        };
+        silence?: {
+            total?: number;
+            count?: number;
+        };
+        interruptions?: {
+            total?: number;
+            byAgent?: number;
+            byCustomer?: number;
+        };
+        duration?: number;
+        longestMonologue?: {
+            speaker?: string;
+            duration?: number;
+        };
+        talkSpeed?: {
+            agent?: number;
+            customer?: number;
+        };
+        questionCount?: {
+            agent?: number;
+            customer?: number;
+        };
+        turnCount?: number;
+    };
+}
+export interface CallMetricsResponse {
+    callId: string;
+    metrics: CallMetrics['metrics'];
+}
+export interface CallTranscript {
+    id: string;
+    callId?: string;
+    audioId?: string;
+    text: string;
+    segments?: Array<{
+        speaker: string;
+        text: string;
+        start: number;
+        end: number;
+        confidence?: number;
+    }>;
+    toolCalls?: ToolCall[];
+    wordCount?: number;
+    speakerCount?: number;
+    language?: string;
+    confidence?: number;
+    status?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CallTranscriptResponse {
+    transcript: CallTranscript | null;
+}
+/**
+ * Input for initiating an outbound call
+ */
+export interface InitiateCallInput {
+    /** Agent ID to handle the call */
+    agentId: string;
+    /** Customer phone number in E.164 format (e.g., "+15551234567") */
+    phone: string;
+    /** Customer name (optional) */
+    customerName?: string;
+    /** Source phone number ID (from channels-service) */
+    phoneNumberId?: string;
+    /** Inline phone number object (alternative to phoneNumberId) */
+    phoneNumber?: {
+        number: string;
+        provider: string;
+    };
+    /** Scorecard ID to evaluate the call against */
+    scorecardId?: string;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Response from initiating a call
+ */
+export interface InitiateCallResponse {
+    id: string;
+    status: CallStatus;
+    providerCallId?: string;
+    agentId: string;
+    customerPhone: string;
+    direction: 'outbound';
+    createdAt: string;
+}
+import { LiveCall } from '../live/live-call';
+import type { LiveOptions } from '../live/types';
+export declare class CallsModule {
+    private sdk;
+    constructor(sdk: ChanlSDK);
+    /**
+     * Initiate an outbound phone call
+     *
+     * Creates a new outbound call to the specified phone number using the given agent.
+     * Requires a source phone number (via phoneNumberId or phoneNumber object).
+     *
+     * @example
+     * ```typescript
+     * // Initiate with phone number ID
+     * const { data } = await sdk.calls.initiate({
+     *   agentId: 'agent_abc',
+     *   phone: '+15551234567',
+     *   phoneNumberId: 'pn_xyz',
+     * });
+     * console.log('Call started:', data.id, data.status);
+     *
+     * // Initiate with inline phone number
+     * const { data } = await sdk.calls.initiate({
+     *   agentId: 'agent_abc',
+     *   phone: '+15551234567',
+     *   phoneNumber: { number: '+18005551234', provider: 'twilio' },
+     *   customerName: 'John Doe',
+     * });
+     * ```
+     */
+    initiate(input: InitiateCallInput): Promise<ApiResponse<InitiateCallResponse>>;
+    /**
+     * List all calls with optional filters
+     *
+     * Supports filtering by standard fields as well as external reference IDs.
+     * External refs use dot notation: `{ externalRefs: { orderId: 'ORDER-123' } }`
+     * becomes `?externalRef.orderId=ORDER-123` in the request.
+     *
+     * @example
+     * ```typescript
+     * // Basic listing
+     * const { data } = await sdk.calls.list();
+     * console.log(data.calls);
+     *
+     * // Filter by status and direction
+     * const { data } = await sdk.calls.list({
+     *   status: 'ended',
+     *   direction: 'inbound',
+     *   page: 1,
+     *   limit: 20
+     * });
+     *
+     * // Filter by external reference IDs
+     * const { data } = await sdk.calls.list({
+     *   externalRefs: {
+     *     orderId: 'ORDER-123',
+     *     customerId: 'cust_456'
+     *   }
+     * });
+     * ```
+     */
+    list(filters?: CallFilters): Promise<ApiResponse<CallListResponse>>;
+    /**
+     * Import a call from transcript, audio URL, audio ID, or S3
+     *
+     * Supports four input modes (at least one required):
+     * 1. **Transcript Only**: Provide transcript text or segments directly (skips Deepgram)
+     * 2. **Audio URL**: Download audio from a URL and transcribe
+     * 3. **Audio ID**: Reference pre-uploaded audio
+     * 4. **S3 Import**: Stream audio from S3 bucket
+     *
+     * @example
+     * ```typescript
+     * // Import with transcript text
+     * const { data } = await sdk.calls.import({
+     *   transcript: 'Agent: Hello! Customer: Hi, I need help...',
+     *   customerName: 'John Doe',
+     *   externalReferenceIds: { orderId: 'ORDER-123' }
+     * });
+     *
+     * // Import with structured transcript segments
+     * const { data } = await sdk.calls.import({
+     *   transcript: [
+     *     { speaker: 'agent', text: 'Hello, how can I help?', startTime: 0, endTime: 2500 },
+     *     { speaker: 'customer', text: 'I have a question about my order.', startTime: 2600, endTime: 5000 }
+     *   ],
+     *   scorecardId: 'scorecard_xyz',
+     *   analysisFields: ['sentiment', 'topics', 'quality']
+     * });
+     *
+     * // Import from audio URL
+     * const { data } = await sdk.calls.import({
+     *   audioUrl: 'https://example.com/recording.mp3',
+     *   customerName: 'Jane Smith',
+     *   agentName: 'Support Agent'
+     * });
+     *
+     * // Import from S3
+     * const { data } = await sdk.calls.import({
+     *   bucket: 'my-recordings',
+     *   key: 'calls/2024/recording.mp3',
+     *   region: 'us-east-1',
+     *   accessKeyId: 'AKIA...',
+     *   secretAccessKey: '...',
+     *   externalReferenceIds: { ticketId: 'TICKET-456' }
+     * });
+     *
+     * // Import with custom extraction fields
+     * const { data } = await sdk.calls.import({
+     *   transcript: '...',
+     *   customExtractions: [
+     *     { key: 'claimNumber', label: 'Claim Number', type: 'string', description: 'Insurance claim ID' },
+     *     { key: 'amount', label: 'Claim Amount', type: 'number' }
+     *   ]
+     * });
+     * ```
+     */
+    import(options: CallImportOptions): Promise<ApiResponse<CallImportResponse>>;
+    /**
+     * Get a single call by ID
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.calls.get('call_abc');
+     * console.log(data.call.status);
+     * ```
+     */
+    get(id: string): Promise<ApiResponse<CallResponse>>;
+    /**
+     * Update a call
+     *
+     * Updates call metadata and properties. Cannot update immutable fields
+     * like providerCallId or transcriptId.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.calls.update('call_abc', {
+     *   customerName: 'Updated Name',
+     *   metadata: {
+     *     tags: ['priority', 'follow-up'],
+     *     customData: { priority: 'high' }
+     *   }
+     * });
+     * ```
+     */
+    update(id: string, data: UpdateCallOptions): Promise<ApiResponse<CallResponse>>;
+    /**
+     * Delete a single call
+     *
+     * Removes the call from the database and optionally cleans up
+     * associated storage files. Does NOT delete from the provider.
+     *
+     * @example
+     * ```typescript
+     * await sdk.calls.delete('call_abc');
+     * ```
+     */
+    delete(id: string): Promise<ApiResponse<{
+        deleted: boolean;
+    }>>;
+    /**
+     * Bulk delete multiple calls
+     *
+     * Deletes up to 100 calls at once. Optionally cleans up associated
+     * storage files. Does NOT delete from the provider.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.calls.bulkDelete('ws_123', {
+     *   callIds: ['call_1', 'call_2', 'call_3'],
+     *   deleteStorageFiles: true
+     * });
+     * console.log(`Deleted ${data.deletedCount} calls`);
+     * ```
+     */
+    bulkDelete(options: BulkDeleteOptions): Promise<ApiResponse<BulkDeleteResponse>>;
+    /**
+     * Trigger analysis for a call
+     *
+     * Analyzes the call using the appropriate scorecard. Automatically creates
+     * a transcript from provider data if missing.
+     *
+     * @example
+     * ```typescript
+     * // Analyze with default scorecard
+     * const { data } = await sdk.calls.analyze('call_abc');
+     * console.log('Status:', data.status);
+     *
+     * // Analyze with specific scorecard
+     * const { data } = await sdk.calls.analyze('call_abc', {
+     *   scorecardId: 'scorecard_xyz',
+     *   forceReanalysis: true
+     * });
+     * ```
+     */
+    analyze(callId: string, options?: AnalyzeCallOptions): Promise<ApiResponse<AnalyzeCallResponse>>;
+    /**
+     * Get analysis results (scorecard evaluations) for a call
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.calls.getAnalysis('ws_123', 'call_abc');
+     * for (const result of data.results) {
+     *   console.log('Score:', result.overallScore);
+     * }
+     * ```
+     */
+    getAnalysis(callId: string): Promise<ApiResponse<CallAnalysisResponse>>;
+    /**
+     * Get call metrics
+     *
+     * Returns calculated metrics including talk time, response time, silence,
+     * interruptions, and enhanced metrics like longest monologue and talk speed.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.calls.getMetrics('ws_123', 'call_abc');
+     * console.log('Talk time:', data.metrics.talkTime);
+     * console.log('Interruptions:', data.metrics.interruptions?.total);
+     * ```
+     */
+    getMetrics(callId: string): Promise<ApiResponse<CallMetricsResponse>>;
+    /**
+     * Get transcript for a call
+     *
+     * Fetches the complete transcript including speaker-segmented dialogue
+     * with timestamps, word count, confidence scores, and language detection.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.calls.getTranscript('ws_123', 'call_abc');
+     * if (data.transcript) {
+     *   console.log('Full text:', data.transcript.text);
+     *   console.log('Segments:', data.transcript.segments?.length);
+     * }
+     * ```
+     */
+    getTranscript(callId: string): Promise<ApiResponse<CallTranscriptResponse>>;
+    /**
+     * Get scorecard evaluation results for a call
+     *
+     * Returns the scorecard results associated with a specific call,
+     * including category scores, criteria results, and overall score.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await sdk.calls.getScorecard('ws_123', 'call_abc');
+     * console.log('Overall score:', data.results?.[0]?.overallScore);
+     * ```
+     */
+    getScorecard(callId: string): Promise<ApiResponse<CallAnalysisResponse>>;
+    /**
+     * Initiate a call and return a LiveCall monitor
+     *
+     * Combines `initiate()` with live monitoring. The returned `LiveCall`
+     * emits events as the call progresses and resolves `.completed` when done.
+     *
+     * @example
+     * ```typescript
+     * const live = await sdk.calls.start({
+     *   agentId: 'agent_abc',
+     *   phone: '+15551234567',
+     *   phoneNumberId: 'pn_xyz',
+     * });
+     * live.on('transcript', (seg) => console.log(`${seg.speaker}: ${seg.text}`));
+     * live.on('ended', (sum) => console.log(`Call ${sum.status}`));
+     * await live.completed;
+     * ```
+     */
+    start(input: InitiateCallInput, options?: LiveOptions): Promise<LiveCall>;
+    /**
+     * Monitor an existing call
+     *
+     * Returns a LiveCall that polls the call's status and transcript,
+     * emitting typed events as data arrives.
+     *
+     * @example
+     * ```typescript
+     * const live = sdk.calls.watch('call_abc');
+     * live.on('status', (s) => console.log('Status:', s));
+     * live.on('transcript', (seg) => console.log(`${seg.speaker}: ${seg.text}`));
+     * await live.completed;
+     * ```
+     */
+    watch(callId: string, options?: LiveOptions): LiveCall;
+}
+//# sourceMappingURL=calls.d.ts.map