@gpt-platform/client 0.10.4 → 0.11.0

package/dist/namespaces/voice.d.ts

@@ -0,0 +1,752 @@
+import type { TranscriptionJob, VoiceRecording, VoiceSession, VoiceTranscriptionResult } from "../_internal/types.gen";
+import type { RequestOptions } from "../base-client";
+import { RequestBuilder } from "../request-builder";
+/**
+ * Return type for `voice.sessions.start()`.
+ *
+ * Narrows the generic `VoiceSession` type to guarantee that `livekit_token`
+ * and `livekit_room` are present, non-null strings. These fields are populated
+ * **only** on the POST /voice/sessions create response (one-time delivery) — the
+ * server never persists the token and it is always null in GET/PATCH responses.
+ *
+ * Using this type instead of `VoiceSession` ensures TypeScript enforces that
+ * callers capture the token before it becomes unavailable.
+ *
+ * @example
+ * ```typescript
+ * const session = await client.voice.sessions.start();
+ * const token: string = session.attributes!.livekit_token;  // guaranteed non-null
+ * ```
+ */
+export type VoiceSessionStart = VoiceSession & {
+    attributes: NonNullable<VoiceSession["attributes"]> & {
+        /** LiveKit JWT for immediate room connection. One-time delivery — capture this immediately. */
+        livekit_token: string;
+        /** LiveKit room name. One-time delivery — capture alongside `livekit_token`. */
+        livekit_room: string;
+    };
+};
+/**
+ * Response from the voice transcription endpoint.
+ * Not a JSON:API resource — this is a plain object response from the
+ * custom VoiceTranscribeController.
+ */
+export interface VoiceTranscribeResult {
+    transcript: string;
+    language_detected: string;
+    duration_seconds: number;
+    processing_seconds: number;
+    segments: Array<{
+        text: string;
+        start: number;
+        end: number;
+        confidence?: number;
+        /** Present when diarization is enabled. Format: "SPEAKER_00", "SPEAKER_01", etc. */
+        speaker_id?: string;
+    }>;
+    phi_mode?: string;
+    phi_entity_count?: number;
+    /** Present when phi_mode is "tokenize". Contains token→original value mappings. */
+    phi_map?: Record<string, string>;
+    /** Advisory: "contains_plaintext_phi" when phi_map is returned in plaintext. */
+    phi_map_sensitivity?: string;
+    /** Present when phi_mode is "tokenize_encrypt". Base64-encoded ciphertext+tag. */
+    phi_map_encrypted?: string;
+    /** Present when phi_mode is "tokenize_encrypt". Base64-encoded 12-byte GCM nonce. */
+    phi_map_nonce?: string;
+}
+/** Options for starting a voice session. */
+export interface VoiceStartOptions {
+    threadId?: string;
+    blueprintId?: string;
+    blueprintMode?: "chat" | "extraction" | "both";
+    phiMode?: "none" | "tokenize" | "tokenize_encrypt";
+    phiKey?: string;
+    patientId?: string;
+}
+/** Options for finalizing a voice session. */
+export interface VoiceFinalizeOptions {
+    blueprintId?: string;
+    phiMode?: "none" | "tokenize" | "tokenize_encrypt";
+    phiKey?: string;
+    patientId?: string;
+}
+/** Options for audio transcription. */
+export interface VoiceTranscribeOptions {
+    language?: string;
+    modelSize?: "base" | "medium" | "large" | "large-v3";
+    phiMode?: "none" | "tokenize" | "tokenize_encrypt";
+    /** Base64-encoded 32 bytes. Required when phiMode is not "none". */
+    phiKey?: string;
+    /** Enable speaker diarization. When true, segments include speaker_id labels. */
+    enableDiarization?: boolean;
+    /** Expected number of speakers (0 = auto-detect). Only used when enableDiarization is true. */
+    numSpeakers?: number;
+    /**
+     * Vocabulary hint for the STT model (Whisper initial_prompt).
+     * Provide domain-specific terms to improve recognition accuracy.
+     * @example "albumin, HbA1c, Metformin, MCT oil, prealbumin"
+     */
+    initialPrompt?: string;
+}
+/** Options for creating a transcription job. */
+export interface TranscriptionJobCreateOptions {
+    language?: string;
+    modelSize?: "base" | "medium" | "large" | "large-v3";
+    enableDiarization?: boolean;
+    numSpeakers?: number;
+    /**
+     * Vocabulary hint for the STT model (Whisper initial_prompt).
+     * @example "albumin, HbA1c, Metformin, MCT oil"
+     */
+    initialPrompt?: string;
+    phiMode?: "none" | "tokenize" | "tokenize_encrypt";
+    metadata?: Record<string, unknown>;
+}
+/** Response from uploading a transcription chunk. */
+export interface TranscriptionChunkResult {
+    chunk_index: number;
+    completed_chunks: number;
+    text: string;
+    segments: Array<{
+        text: string;
+        start: number;
+        end: number;
+        confidence?: number;
+        speaker_id?: string;
+    }>;
+    language_detected: string;
+    duration_seconds: number;
+    processing_seconds: number;
+}
+/** Options for finalizing a transcription job. */
+export interface TranscriptionJobFinalizeOptions {
+    blueprintId?: string;
+    patientId?: string;
+}
+/** Response from finalizing a transcription job. */
+export interface TranscriptionJobFinalizeResult {
+    job_id: string;
+    status: "completed";
+    assembled_text: string;
+    segments: Array<{
+        text: string;
+        start: number;
+        end: number;
+        confidence?: number;
+        speaker_id?: string;
+    }>;
+    total_duration_seconds: number;
+    total_chunks: number;
+    transcription_result_id: string | null;
+}
+/**
+ * Voice namespace for audio transcription and real-time voice session management.
+ *
+ * Access via `client.voice`.
+ *
+ * The voice system has two independent capabilities:
+ * - **Transcription** (`transcribe`) — one-shot audio file transcription with
+ *   optional PHI tokenization.
+ * - **Sessions** — long-running LiveKit-backed voice sessions for real-time
+ *   clinical conversations, with post-session pipeline integration.
+ *
+ * @example
+ * ```typescript
+ * const client = new GptClient({ apiKey: 'sk_app_...' });
+ *
+ * // Transcribe a recorded audio file
+ * const result = await client.voice.transcribe(audioBlob, { language: 'en' });
+ * console.log(result.transcript);
+ *
+ * // Start a real-time session
+ * const session = await client.voice.sessions.start({ blueprintId: 'bp_abc123' });
+ * const token = session.attributes.livekit_token; // capture immediately
+ * ```
+ */
+export declare function createVoiceNamespace(rb: RequestBuilder): {
+    /**
+     * Transcribe an audio file to text.
+     *
+     * Submits an audio file to the voice transcription pipeline. The file is
+     * processed synchronously (the request blocks until transcription completes).
+     * Supported formats: mp3, ogg, wav, m4a, webm, flac, aac. Maximum file
+     * size: 200 MB.
+     *
+     * PHI handling modes:
+     * - `"none"` (default) — transcript returned as-is, no PHI processing.
+     * - `"tokenize"` — PHI entities replaced with placeholder tokens in the
+     *   transcript; a `phi_map` is returned mapping tokens back to original values.
+     * - `"tokenize_encrypt"` — same as tokenize but `phi_map` is AES-256-GCM
+     *   encrypted; requires a `phiKey` (Base64-encoded 32 bytes).
+     *
+     * @param audio - The audio file or blob to transcribe (max 200 MB).
+     * @param params - Optional transcription parameters.
+     * @param params.language - BCP-47 language hint (e.g., `"en"`, `"fr"`).
+     *   Improves accuracy when the language is known.
+     * @param params.modelSize - Whisper model size to use. Larger models are
+     *   more accurate but slower. Defaults to `"medium"`.
+     * @param params.phiMode - PHI handling mode. Defaults to `"none"`.
+     * @param params.phiKey - AES-256 key as Base64 (32 raw bytes). Required
+     *   when `phiMode` is `"tokenize_encrypt"`. Treat as a secret — never log.
+     * @param options - Optional request options (signal for cancellation, etc.).
+     * @returns A `VoiceTranscribeResult` with transcript, segments, and optional PHI data.
+     *
+     * @example
+     * ```typescript
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     * const fileInput = document.querySelector<HTMLInputElement>('#audio-upload')!;
+     * const [audioFile] = fileInput.files!;
+     *
+     * const result = await client.voice.transcribe(audioFile, {
+     *   language: 'en',
+     *   modelSize: 'medium',
+     * });
+     * console.log(result.transcript);
+     * console.log(`Transcribed ${result.duration_seconds}s in ${result.processing_seconds}s`);
+     * result.segments.forEach(s => console.log(`[${s.start}–${s.end}] ${s.text}`));
+     * ```
+     */
+    transcribe: (audio: File | Blob, params?: VoiceTranscribeOptions, options?: RequestOptions) => Promise<VoiceTranscribeResult>;
+    /**
+     * Sessions — real-time voice session lifecycle management.
+     *
+     * Voice sessions are backed by LiveKit rooms. Each session tracks the
+     * full conversation lifecycle from room creation through post-session
+     * processing (notes, summaries, clinical alerts).
+     *
+     * Typical session flow:
+     * 1. `start()` — provisions a LiveKit room, returns one-time token.
+     * 2. Client connects to LiveKit using the token.
+     * 3. `stop(id)` — ends the session and releases the room.
+     * 4. `finalize(id)` — triggers post-session processing pipeline.
+     */
+    sessions: {
+        /**
+         * List voice sessions with optional pagination.
+         *
+         * Returns sessions accessible to the current actor, ordered by
+         * `created_at` descending.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `VoiceSession` records.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const sessions = await client.voice.sessions.list({ page: 1, pageSize: 20 });
+         * sessions.forEach(s => console.log(s.attributes?.status, s.attributes?.created_at));
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+            /** Filter sessions by status. */
+            status?: "active" | "ended" | "failed" | "timed_out";
+            /** Filter sessions created after this ISO 8601 timestamp. */
+            insertedAfter?: string;
+            /** Filter sessions created before this ISO 8601 timestamp. */
+            insertedBefore?: string;
+        } & RequestOptions) => Promise<VoiceSession[]>;
+        /**
+         * Retrieve a single voice session by its ID.
+         *
+         * Note: `livekit_token` and `livekit_room` are always `null` in GET
+         * responses — they are only returned on the initial `start()` call.
+         *
+         * @param id - The UUID of the voice session.
+         * @param options - Optional request options.
+         * @returns The matching `VoiceSession`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const session = await client.voice.sessions.get('vs_abc123');
+         * console.log(session.attributes?.status, session.attributes?.duration_seconds);
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<VoiceSession>;
+        /**
+         * List voice sessions belonging to the currently authenticated user.
+         *
+         * Returns only sessions where the current user is the session owner.
+         *
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `VoiceSession` records owned by the current user.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const mySessions = await client.voice.sessions.listMine({ pageSize: 10 });
+         * ```
+         */
+        listMine: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<VoiceSession[]>;
+        /**
+         * List voice sessions scoped to a specific workspace.
+         *
+         * @param workspaceId - The UUID of the workspace to list sessions for.
+         * @param options - Optional page number, page size, and request options.
+         * @returns A page of `VoiceSession` records in the given workspace.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const sessions = await client.voice.sessions.listByWorkspace('ws_abc123');
+         * ```
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<VoiceSession[]>;
+        /**
+         * Start a new voice session with LiveKit room provisioning.
+         *
+         * Creates a `VoiceSession` record, provisions a LiveKit room, and returns
+         * a one-time JWT (`livekit_token`) and room name (`livekit_room`).
+         * **These values are delivered only once** — the server does not persist
+         * the token and it will always be `null` in subsequent GET requests.
+         * Capture both values immediately before any other operations.
+         *
+         * @param params - Session startup parameters.
+         * @param params.threadId - Optional chat thread ID to associate this session with.
+         * @param params.blueprintId - Optional agent blueprint ID. When provided, the
+         *   session's transcript is processed by this blueprint on finalization.
+         * @param params.blueprintMode - How the blueprint processes the session.
+         *   `"chat"` — sends to chat pipeline; `"extraction"` — runs extraction;
+         *   `"both"` — runs both pipelines.
+         * @param params.phiMode - PHI handling mode for the session transcript.
+         *   `"none"` | `"tokenize"` | `"tokenize_encrypt"`.
+         * @param params.phiKey - AES-256 encryption key as Base64 (32 raw bytes).
+         *   Required when `phiMode` is `"tokenize_encrypt"`. Treat as a secret —
+         *   never log, store in `localStorage`, or include in error reports.
+         *   The server never persists this key.
+         * @param params.patientId - Optional CRM patient/contact ID to associate
+         *   the session with for clinical workflows.
+         * @param options - Optional request options.
+         * @returns A `VoiceSessionStart` with guaranteed non-null `livekit_token`
+         *   and `livekit_room`.
+         *
+         * @remarks
+         * **Security — `phiKey`:** Transmitted over HTTPS only. Never send over
+         * plain HTTP. Do not log or store this value outside the request.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const session = await client.voice.sessions.start({
+         *   blueprintId: 'bp_clinical_notes',
+         *   blueprintMode: 'both',
+         *   patientId: 'contact_abc123',
+         * });
+         *
+         * // Capture token immediately — it's only available on start
+         * const { livekit_token, livekit_room } = session.attributes;
+         * await connectToLiveKit(livekit_room, livekit_token);
+         * ```
+         */
+        start: (params?: VoiceStartOptions, options?: RequestOptions) => Promise<VoiceSessionStart>;
+        /**
+         * End an active voice session and release the LiveKit room.
+         *
+         * Signals the server to close the LiveKit room and mark the session
+         * as `"ended"`. The `ended_at` timestamp is set automatically by the
+         * server. No request body attributes are accepted — passing extra
+         * attributes will result in a 422 validation error.
+         *
+         * After stopping, call `finalize` to trigger post-session processing
+         * (note generation, summarization, clinical alerts).
+         *
+         * @param id - The UUID of the voice session to stop.
+         * @param options - Optional request options.
+         * @returns The updated `VoiceSession` with `status: "ended"`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const session = await client.voice.sessions.stop('vs_abc123');
+         * console.log(session.attributes?.status); // "ended"
+         * console.log(session.attributes?.ended_at);
+         * ```
+         */
+        stop: (id: string, options?: RequestOptions) => Promise<VoiceSession>;
+        /**
+         * Trigger post-session processing for a stopped voice session.
+         *
+         * Dispatches the accumulated session transcript to the configured
+         * blueprint or chat pipeline. Depending on the session's `blueprint_mode`,
+         * this may trigger: clinical note generation, extraction, chat summarization,
+         * trend analysis, and clinical alert workers.
+         *
+         * Typically called immediately after `stop`. The session must be in
+         * `"ended"` status before calling `finalize`.
+         *
+         * @param id - The UUID of the voice session to finalize.
+         * @param params - Finalization parameters (override session-level settings).
+         * @param params.blueprintId - Override the blueprint to use for processing.
+         * @param params.phiMode - Override the PHI handling mode for the transcript.
+         * @param params.phiKey - AES-256 encryption key as Base64 (32 raw bytes).
+         *   Overrides the key supplied at session start. Required when `phiMode`
+         *   is `"tokenize_encrypt"`. Treat as a secret — never log or store.
+         * @param params.patientId - Override the patient ID for clinical association.
+         * @param options - Optional request options.
+         * @returns The updated `VoiceSession` with `finalized_at` timestamp set.
+         *
+         * @remarks
+         * **Security — transcript PHI:** The transcript submitted to this endpoint
+         * may contain Protected Health Information. Ensure the request is made
+         * over HTTPS only.
+         *
+         * **Security — `phiKey`:** Transmitted over HTTPS only. Never log, store
+         * in `localStorage`, or include in error reports.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         *
+         * // After stopping the session:
+         * const finalized = await client.voice.sessions.finalize('vs_abc123', {
+         *   blueprintId: 'bp_clinical_notes',
+         *   patientId: 'contact_abc123',
+         * });
+         * console.log(finalized.attributes?.status); // "finalizing"
+         * ```
+         */
+        finalize: (id: string, params?: VoiceFinalizeOptions, options?: RequestOptions) => Promise<VoiceSession>;
+        /**
+         * Destroy a voice session.
+         *
+         * @param id - The voice session ID to destroy
+         * @param options - Optional request configuration
+         * @returns Promise resolving when session is destroyed
+         *
+         * @example
+         * ```typescript
+         * await client.voice.sessions.destroy('session-uuid');
+         * ```
+         */
+        destroy: (id: string, options?: RequestOptions) => Promise<void>;
+    };
+    /**
+     * Voice recordings — recordings for the current workspace.
+     */
+    recordings: {
+        /**
+         * List voice recordings.
+         *
+         * @param options - Optional pagination and request options.
+         * @returns Array of VoiceRecording objects.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const recordings = await client.voice.recordings.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<VoiceRecording[]>;
+        /**
+         * Retrieve a single recording by ID.
+         *
+         * @param id - The UUID of the recording.
+         * @param options - Optional request options.
+         * @returns The VoiceRecording.
+         *
+         * @example
+         * ```typescript
+         * const recording = await client.voice.recordings.get('recording-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<VoiceRecording>;
+        /**
+         * List all recordings for a specific voice session.
+         *
+         * @param sessionId - The UUID of the voice session.
+         * @param options - Optional request options.
+         * @returns Array of VoiceRecording objects for the session.
+         *
+         * @example
+         * ```typescript
+         * const recordings = await client.voice.recordings.bySession('session-uuid');
+         * ```
+         */
+        bySession: (sessionId: string, options?: RequestOptions) => Promise<VoiceRecording[]>;
+    };
+    /**
+     * Transcription results — results for sessions in the current workspace.
+     */
+    transcriptionResults: {
+        /**
+         * List transcription results.
+         *
+         * @param options - Optional pagination and request options.
+         * @returns Array of VoiceTranscriptionResult objects.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const results = await client.voice.transcriptionResults.list();
+         * ```
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<VoiceTranscriptionResult[]>;
+        /**
+         * Retrieve a single transcription result by ID.
+         *
+         * @param id - The UUID of the transcription result.
+         * @param options - Optional request options.
+         * @returns The VoiceTranscriptionResult.
+         *
+         * @example
+         * ```typescript
+         * const result = await client.voice.transcriptionResults.get('result-uuid');
+         * ```
+         */
+        get: (id: string, options?: RequestOptions) => Promise<VoiceTranscriptionResult>;
+        /**
+         * List transcription results for a specific voice session.
+         *
+         * @param sessionId - The UUID of the voice session.
+         * @param options - Optional pagination and request options.
+         * @returns Array of VoiceTranscriptionResult objects for the session.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const results = await client.voice.transcriptionResults.bySession('session-uuid');
+         * ```
+         */
+        bySession: (sessionId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<VoiceTranscriptionResult[]>;
+        /**
+         * Create a transcript record manually.
+         *
+         * Creates a `VoiceTranscriptionResult` record in the current workspace.
+         * Useful when you have a pre-computed transcript (e.g. from an external STT
+         * service) that you want to associate with a recording or session.
+         *
+         * @param attributes - Transcript data. Required: `text` (string).
+         *   Optional: `recording_id`, `session_id`, `document_id`, `segments`,
+         *   `language_detected`, `duration_seconds`, `processing_seconds`,
+         *   `stt_engine`, `stt_model`, `metadata`.
+         * @param options - Optional request options.
+         * @returns The created `VoiceTranscriptionResult`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const result = await client.voice.transcriptionResults.create({
+         *   text: 'Patient reports chest pain since this morning.',
+         *   session_id: 'vs_abc123',
+         *   language_detected: 'en',
+         *   duration_seconds: 47.2,
+         * });
+         * console.log(result.id);
+         * ```
+         */
+        create: (attributes: {
+            text: string;
+            recording_id?: string;
+            session_id?: string;
+            document_id?: string;
+            segments?: Array<{
+                text: string;
+                start: number;
+                end: number;
+                confidence?: number;
+            }>;
+            language_detected?: string;
+            duration_seconds?: number;
+            processing_seconds?: number;
+            stt_engine?: string;
+            stt_model?: string;
+            metadata?: Record<string, unknown>;
+        }, options?: RequestOptions) => Promise<VoiceTranscriptionResult>;
+        /**
+         * Update a transcript's text, segments, or metadata.
+         *
+         * Allows correcting transcript text after review, updating segments
+         * with corrected timestamps or confidence scores, or annotating with
+         * additional metadata. `recording_id`, `session_id`, and STT engine
+         * fields are immutable after creation.
+         *
+         * @param id - The UUID of the transcription result to update.
+         * @param attributes - Fields to update. One or more of: `text`, `segments`, `metadata`.
+         * @param options - Optional request options.
+         * @returns The updated `VoiceTranscriptionResult`.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * const updated = await client.voice.transcriptionResults.update('tr_abc123', {
+         *   text: 'Patient reports chest pain since yesterday morning.',
+         * });
+         * ```
+         */
+        update: (id: string, attributes: {
+            text?: string;
+            segments?: Array<{
+                text: string;
+                start: number;
+                end: number;
+                confidence?: number;
+            }>;
+            metadata?: Record<string, unknown>;
+        }, options?: RequestOptions) => Promise<VoiceTranscriptionResult>;
+        /**
+         * Delete a transcription result by its ID.
+         *
+         * Permanently removes the transcript record. Associated recordings and
+         * voice sessions are not affected.
+         *
+         * @param id - The UUID of the transcription result to delete.
+         * @param options - Optional request options.
+         * @returns A promise that resolves when the record is deleted.
+         *
+         * @example
+         * ```typescript
+         * const client = new GptClient({ apiKey: 'sk_app_...' });
+         * await client.voice.transcriptionResults.destroy('tr_abc123');
+         * ```
+         */
+        destroy: (id: string, options?: RequestOptions) => Promise<void>;
+    };
+    /**
+     * Transcription jobs — progressive chunked transcription for long recordings.
+     *
+     * Designed for clinical recording sessions (30–60 minutes). The browser records
+     * audio and uploads chunks every 2–3 minutes. Each chunk is transcribed
+     * synchronously on upload. On finalize, chunks are assembled into a complete
+     * diarized transcript.
+     *
+     * Typical flow:
+     * 1. `create()` — start a new transcription job with config (language, diarization, etc.)
+     * 2. `uploadChunk(jobId, audioBlob)` — upload each chunk as it's recorded
+     * 3. `finalize(jobId)` — assemble all chunks and optionally trigger pipeline
+     *
+     * Subscribe to the `voice:{workspace_id}` WebSocket channel for real-time
+     * progress events: `transcription:chunk_completed`, `transcription:job_completed`.
+     *
+     * @example
+     * ```typescript
+     * const client = new GptClient({ apiKey: 'sk_app_...' });
+     *
+     * // Create job with medical vocabulary hints
+     * const job = await client.voice.transcriptionJobs.create({
+     *   language: 'en',
+     *   modelSize: 'large',
+     *   enableDiarization: true,
+     *   numSpeakers: 2,
+     *   initialPrompt: 'albumin, HbA1c, Metformin, MCT oil, prealbumin',
+     * });
+     *
+     * // Upload chunks as they're recorded (MediaRecorder ondataavailable)
+     * mediaRecorder.ondataavailable = async (event) => {
+     *   if (event.data.size > 0) {
+     *     const result = await client.voice.transcriptionJobs.uploadChunk(
+     *       job.id!, event.data
+     *     );
+     *     console.log(`Chunk ${result.chunk_index}: ${result.text}`);
+     *   }
+     * };
+     *
+     * // Finalize after recording stops
+     * const transcript = await client.voice.transcriptionJobs.finalize(job.id!, {
+     *   blueprintId: 'bp_clinical_notes',
+     *   patientId: 'contact_abc123',
+     * });
+     * console.log(transcript.assembled_text);
+     * ```
+     */
+    transcriptionJobs: {
+        /**
+         * Create a new transcription job.
+         *
+         * @param params - Job configuration (language, model, diarization, vocabulary hints).
+         * @param options - Optional request options.
+         * @returns The created TranscriptionJob resource (JSON:API format).
+         */
+        create: (params?: TranscriptionJobCreateOptions, options?: RequestOptions) => Promise<TranscriptionJob>;
+        /**
+         * Get a transcription job by ID.
+         *
+         * @param id - The UUID of the transcription job.
+         * @param options - Optional request options.
+         * @returns The TranscriptionJob resource.
+         */
+        get: (id: string, options?: RequestOptions) => Promise<TranscriptionJob>;
+        /**
+         * List transcription jobs for the current user.
+         *
+         * @param options - Optional pagination and request options.
+         * @returns Array of TranscriptionJob resources.
+         */
+        listMine: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<TranscriptionJob[]>;
+        /**
+         * List all transcription jobs accessible to the current actor.
+         *
+         * @param options - Optional pagination and request options.
+         * @returns Array of TranscriptionJob resources.
+         */
+        list: (options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<TranscriptionJob[]>;
+        /**
+         * List transcription jobs for a specific workspace.
+         *
+         * @param workspaceId - The UUID of the workspace.
+         * @param options - Optional pagination and request options.
+         * @returns Array of TranscriptionJob resources.
+         */
+        listByWorkspace: (workspaceId: string, options?: {
+            page?: number;
+            pageSize?: number;
+        } & RequestOptions) => Promise<TranscriptionJob[]>;
+        /**
+         * Upload and transcribe an audio chunk.
+         *
+         * The chunk is transcribed synchronously. For 2–3 minute chunks, expect
+         * 10–20 seconds of processing time. The response includes the chunk's
+         * transcript and segments (with speaker_id if diarization is enabled).
+         *
+         * @param jobId - The UUID of the transcription job.
+         * @param audio - The audio chunk (File or Blob). Max 50 MB.
+         * @param options - Optional request options.
+         * @returns Chunk transcription result with text, segments, and timing.
+         */
+        uploadChunk: (jobId: string, audio: File | Blob, options?: RequestOptions) => Promise<TranscriptionChunkResult>;
+        /**
+         * Finalize a transcription job — assemble chunks into a complete transcript.
+         *
+         * Joins all chunk transcripts in order, offsets segment timestamps, and
+         * reconciles speaker IDs across chunks. Optionally triggers a blueprint
+         * pipeline (e.g., SOAP note generation) on the assembled transcript.
+         *
+         * @param jobId - The UUID of the transcription job to finalize.
+         * @param params - Optional pipeline trigger parameters.
+         * @param options - Optional request options.
+         * @returns The assembled transcript with full text, segments, and timing.
+         */
+        finalize: (jobId: string, params?: TranscriptionJobFinalizeOptions, options?: RequestOptions) => Promise<TranscriptionJobFinalizeResult>;
+        /**
+         * Delete a transcription job.
+         *
+         * @param id - The UUID of the transcription job to delete.
+         * @param options - Optional request options.
+         */
+        destroy: (id: string, options?: RequestOptions) => Promise<void>;
+    };
+};
+//# sourceMappingURL=voice.d.ts.map