@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/dist/recordings.d.ts

@@ -0,0 +1,1371 @@
+import { z } from "zod";
+/**
+ * Recordings: captured conversations (meetings, interviews, site walks) with
+ * one or more audio tracks, versioned transcripts and editable speakers.
+ * Visibility matches chats: "private" is Only me, "workspace" is shared.
+ */
+export declare const RECORDING_MAX_TRACKS = 8;
+export declare const RECORDING_MAX_CHUNK_BYTES: number;
+export declare const RECORDING_MAX_DURATION_MILLISECONDS: number;
+export declare const RECORDING_UPLOAD_BATCH_MAX = 50;
+/**
+ * The audio containers a track can be captured in: WebM or Ogg Opus and MP4
+ * AAC from browsers, and an ADTS AAC stream from phones, whose frames
+ * concatenate across chunks the way WebM clusters do.
+ */
+export type RecordingAudioContainer = "webm" | "mp4" | "ogg" | "aac";
+/** The container a track's MIME type names, or null when recordings cannot use it. */
+export declare function recordingAudioContainer(mimeType: string): RecordingAudioContainer | null;
+export declare const RecordingVisibility: z.ZodEnum<{
+    private: "private";
+    workspace: "workspace";
+}>;
+export type RecordingVisibility = z.infer<typeof RecordingVisibility>;
+export declare const RecordingState: z.ZodEnum<{
+    capturing: "capturing";
+    failed: "failed";
+    processing: "processing";
+    ready: "ready";
+}>;
+export type RecordingState = z.infer<typeof RecordingState>;
+/**
+ * What a recorder can capture into a track. microphone: the person
+ * recording; system: the computer's audio (the other side).
+ */
+export declare const RecordingCaptureSource: z.ZodEnum<{
+    microphone: "microphone";
+    mixed: "mixed";
+    system: "system";
+    upload: "upload";
+}>;
+export type RecordingCaptureSource = z.infer<typeof RecordingCaptureSource>;
+/** Where a track came from: a recorder's capture, or a browser tab an agent recorded. */
+export declare const RecordingTrackSource: z.ZodEnum<{
+    browser_tab: "browser_tab";
+    microphone: "microphone";
+    mixed: "mixed";
+    system: "system";
+    upload: "upload";
+}>;
+export type RecordingTrackSource = z.infer<typeof RecordingTrackSource>;
+export declare const RecordingTrackKind: z.ZodEnum<{
+    audio: "audio";
+    video: "video";
+}>;
+export type RecordingTrackKind = z.infer<typeof RecordingTrackKind>;
+/**
+ * meeting: a recorded conversation, listed in Meetings. browser: an agent's
+ * browser recording, a video of the tab with a log of what the agent did.
+ * dictation: speech someone records to type it, such as into the chat box;
+ * always private, never listed, and deleted a day after it is transcribed.
+ */
+export declare const RecordingPurpose: z.ZodEnum<{
+    browser: "browser";
+    dictation: "dictation";
+    meeting: "meeting";
+}>;
+export type RecordingPurpose = z.infer<typeof RecordingPurpose>;
+/** What a client may record: browser recordings are made by the server. */
+export declare const RecordingCapturePurpose: z.ZodEnum<{
+    dictation: "dictation";
+    meeting: "meeting";
+}>;
+export type RecordingCapturePurpose = z.infer<typeof RecordingCapturePurpose>;
+/** How long a dictation is kept after it is transcribed, for the client to take its text. */
+export declare const DICTATION_RETENTION_MILLISECONDS: number;
+export declare const RecordingTranscriptVersionState: z.ZodEnum<{
+    complete: "complete";
+    failed: "failed";
+    processing: "processing";
+    queued: "queued";
+}>;
+export type RecordingTranscriptVersionState = z.infer<typeof RecordingTranscriptVersionState>;
+export declare const RecordingSpeakerSource: z.ZodEnum<{
+    carried_over: "carried_over";
+    confirmed: "confirmed";
+    suggested: "suggested";
+    track: "track";
+}>;
+export type RecordingSpeakerSource = z.infer<typeof RecordingSpeakerSource>;
+/**
+ * Who told the speakers apart in a version: the transcription provider, our
+ * own diarizer, the tracks alone (microphone versus system audio), or nobody.
+ */
+export declare const RecordingDiarization: z.ZodEnum<{
+    none: "none";
+    ours: "ours";
+    provider: "provider";
+    tracks: "tracks";
+}>;
+export type RecordingDiarization = z.infer<typeof RecordingDiarization>;
+/**
+ * Who tells speakers apart: `auto` uses the model's own diarization when it
+ * has one and Opengeni's otherwise; `ours` always uses Opengeni's, for the
+ * same speakers whatever the model.
+ */
+export declare const RecordingDiarizer: z.ZodEnum<{
+    auto: "auto";
+    ours: "ours";
+}>;
+export type RecordingDiarizer = z.infer<typeof RecordingDiarizer>;
+/** How to transcribe; every field is optional and falls back to workspace defaults. */
+export declare const RecordingTranscriptionOptions: z.ZodObject<{
+    providerId: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    maxSpeakers: z.ZodOptional<z.ZodNumber>;
+    keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    diarizer: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        ours: "ours";
+    }>>;
+}, z.core.$strict>;
+export type RecordingTranscriptionOptions = z.infer<typeof RecordingTranscriptionOptions>;
+/**
+ * How to transcribe, as asked for. A new recording that names no language
+ * takes the workspace's meeting language; `null` detects it even then.
+ */
+export declare const RecordingTranscriptionRequest: z.ZodObject<{
+    providerId: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    maxSpeakers: z.ZodOptional<z.ZodNumber>;
+    keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    diarizer: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        ours: "ours";
+    }>>;
+    language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type RecordingTranscriptionRequest = z.infer<typeof RecordingTranscriptionRequest>;
+/**
+ * How long a workspace keeps meetings, in days after they were recorded.
+ * Audio can go sooner than the transcript, never later.
+ */
+export declare const RecordingRetention: z.ZodObject<{
+    audioDays: z.ZodOptional<z.ZodNumber>;
+    transcriptDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type RecordingRetention = z.infer<typeof RecordingRetention>;
+/**
+ * When retention deletes a meeting's audio and the meeting itself, counted
+ * from when it was recorded. Null where nothing is set. The sweep runs every
+ * few minutes, so deletion follows shortly after.
+ */
+export declare function recordingRetentionDates(retention: RecordingRetention | undefined, recordedAt: Date): {
+    audio: Date | null;
+    meeting: Date | null;
+};
+/**
+ * A workspace's recording defaults. New recordings are Only me unless the
+ * workspace says otherwise; products may always set visibility explicitly.
+ */
+export declare const WorkspaceRecordingSettings: z.ZodObject<{
+    defaultVisibility: z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        workspace: "workspace";
+    }>>;
+    transcription: z.ZodOptional<z.ZodObject<{
+        providerId: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+    diarizer: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        ours: "ours";
+    }>>;
+    language: z.ZodOptional<z.ZodString>;
+    voiceprints: z.ZodOptional<z.ZodBoolean>;
+    liveTranscript: z.ZodOptional<z.ZodBoolean>;
+    autoSummary: z.ZodOptional<z.ZodBoolean>;
+    retention: z.ZodOptional<z.ZodObject<{
+        audioDays: z.ZodOptional<z.ZodNumber>;
+        transcriptDays: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WorkspaceRecordingSettings = z.infer<typeof WorkspaceRecordingSettings>;
+/** Read a workspace's recording defaults leniently; a bad value means none. */
+export declare function resolveWorkspaceRecordingSettings(settings: unknown): WorkspaceRecordingSettings;
+export declare const CreateRecordingRequest: z.ZodObject<{
+    recordingId: z.ZodString;
+    purpose: z.ZodOptional<z.ZodEnum<{
+        dictation: "dictation";
+        meeting: "meeting";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        workspace: "workspace";
+    }>>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    externalRef: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    tracks: z.ZodArray<z.ZodObject<{
+        trackNumber: z.ZodNumber;
+        source: z.ZodEnum<{
+            microphone: "microphone";
+            mixed: "mixed";
+            system: "system";
+            upload: "upload";
+        }>;
+        mimeType: z.ZodString;
+    }, z.core.$strict>>;
+    transcription: z.ZodOptional<z.ZodObject<{
+        providerId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        maxSpeakers: z.ZodOptional<z.ZodNumber>;
+        keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        diarizer: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            ours: "ours";
+        }>>;
+        language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+    ownerName: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CreateRecordingRequest = z.infer<typeof CreateRecordingRequest>;
+export declare const RecordingChunkDescriptor: z.ZodObject<{
+    chunkNumber: z.ZodNumber;
+    byteLength: z.ZodNumber;
+    sha256: z.ZodString;
+    startMilliseconds: z.ZodNumber;
+    durationMilliseconds: z.ZodNumber;
+}, z.core.$strict>;
+export type RecordingChunkDescriptor = z.infer<typeof RecordingChunkDescriptor>;
+/** Reserve chunks and get presigned URLs to PUT their bytes straight to storage. */
+export declare const CreateRecordingUploadsRequest: z.ZodObject<{
+    trackNumber: z.ZodNumber;
+    chunks: z.ZodArray<z.ZodObject<{
+        chunkNumber: z.ZodNumber;
+        byteLength: z.ZodNumber;
+        sha256: z.ZodString;
+        startMilliseconds: z.ZodNumber;
+        durationMilliseconds: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CreateRecordingUploadsRequest = z.infer<typeof CreateRecordingUploadsRequest>;
+export declare const RecordingChunkUpload: z.ZodObject<{
+    chunkNumber: z.ZodNumber;
+    uploaded: z.ZodBoolean;
+    url: z.ZodNullable<z.ZodString>;
+    method: z.ZodLiteral<"PUT">;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type RecordingChunkUpload = z.infer<typeof RecordingChunkUpload>;
+export declare const CreateRecordingUploadsResponse: z.ZodObject<{
+    uploads: z.ZodArray<z.ZodObject<{
+        chunkNumber: z.ZodNumber;
+        uploaded: z.ZodBoolean;
+        url: z.ZodNullable<z.ZodString>;
+        method: z.ZodLiteral<"PUT">;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        expiresAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreateRecordingUploadsResponse = z.infer<typeof CreateRecordingUploadsResponse>;
+/** Confirm chunks whose bytes were PUT; the server checks each object first. */
+export declare const CompleteRecordingChunksRequest: z.ZodObject<{
+    trackNumber: z.ZodNumber;
+    chunkNumbers: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>;
+export type CompleteRecordingChunksRequest = z.infer<typeof CompleteRecordingChunksRequest>;
+export declare const CompleteRecordingChunksResponse: z.ZodObject<{
+    uploaded: z.ZodArray<z.ZodNumber>;
+    missing: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export type CompleteRecordingChunksResponse = z.infer<typeof CompleteRecordingChunksResponse>;
+/** Capture is over: every listed chunk must be uploaded. Starts transcription. */
+export declare const FinalizeRecordingRequest: z.ZodObject<{
+    endedAt: z.ZodOptional<z.ZodString>;
+    tracks: z.ZodArray<z.ZodObject<{
+        trackNumber: z.ZodNumber;
+        chunkCount: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FinalizeRecordingRequest = z.infer<typeof FinalizeRecordingRequest>;
+export declare const UpdateRecordingRequest: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        workspace: "workspace";
+    }>>;
+    externalRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+}, z.core.$strict>;
+export type UpdateRecordingRequest = z.infer<typeof UpdateRecordingRequest>;
+/** Start a new transcript version over the recording's audio. */
+export declare const CreateRecordingTranscriptRequest: z.ZodObject<{
+    transcription: z.ZodOptional<z.ZodObject<{
+        providerId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        maxSpeakers: z.ZodOptional<z.ZodNumber>;
+        keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        diarizer: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            ours: "ours";
+        }>>;
+        language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CreateRecordingTranscriptRequest = z.infer<typeof CreateRecordingTranscriptRequest>;
+/**
+ * Name speakers in one version. An assignment names a label (a person from
+ * the directory, or a plain name); a segment override moves one segment to
+ * another label. Assigning two labels to one person merges them.
+ */
+export declare const UpdateRecordingSpeakersRequest: z.ZodObject<{
+    assignments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        personId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>;
+    segmentOverrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        segmentIndex: z.ZodNumber;
+        label: z.ZodString;
+    }, z.core.$strict>>>;
+    rejectSuggestions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type UpdateRecordingSpeakersRequest = z.infer<typeof UpdateRecordingSpeakersRequest>;
+/**
+ * Agree to have a person's voice remembered. `self` is a member agreeing
+ * for themselves; `attested` is someone confirming that a person outside
+ * the workspace agreed. Members can only agree for themselves.
+ */
+export declare const RecordingVoiceprintConsent: z.ZodEnum<{
+    attested: "attested";
+    self: "self";
+}>;
+export type RecordingVoiceprintConsent = z.infer<typeof RecordingVoiceprintConsent>;
+export declare const RememberRecordingPersonVoiceRequest: z.ZodObject<{
+    consent: z.ZodEnum<{
+        attested: "attested";
+        self: "self";
+    }>;
+}, z.core.$strict>;
+export type RememberRecordingPersonVoiceRequest = z.infer<typeof RememberRecordingPersonVoiceRequest>;
+/**
+ * Correct the text of segments in one version. The version itself never
+ * changes; edits are a layer on top. `text: null` reverts to the original.
+ */
+export declare const UpdateRecordingSegmentsRequest: z.ZodObject<{
+    edits: z.ZodArray<z.ZodObject<{
+        segmentIndex: z.ZodNumber;
+        text: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type UpdateRecordingSegmentsRequest = z.infer<typeof UpdateRecordingSegmentsRequest>;
+export declare const CreateRecordingPersonRequest: z.ZodObject<{
+    personId: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    memberSubjectId: z.ZodOptional<z.ZodString>;
+    externalRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CreateRecordingPersonRequest = z.infer<typeof CreateRecordingPersonRequest>;
+export declare const RecordingTrack: z.ZodObject<{
+    trackNumber: z.ZodNumber;
+    kind: z.ZodEnum<{
+        audio: "audio";
+        video: "video";
+    }>;
+    source: z.ZodEnum<{
+        browser_tab: "browser_tab";
+        microphone: "microphone";
+        mixed: "mixed";
+        system: "system";
+        upload: "upload";
+    }>;
+    mimeType: z.ZodString;
+    chunkCount: z.ZodNumber;
+    totalBytes: z.ZodNumber;
+    durationMilliseconds: z.ZodNumber;
+    playable: z.ZodBoolean;
+    video: z.ZodNullable<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        frameCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    live: z.ZodNullable<z.ZodObject<{
+        providerId: z.ZodString;
+        model: z.ZodString;
+        streamedMilliseconds: z.ZodNumber;
+        costUsd: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RecordingTrack = z.infer<typeof RecordingTrack>;
+export declare const RecordingTranscriptVersion: z.ZodObject<{
+    id: z.ZodString;
+    recordingId: z.ZodString;
+    versionNumber: z.ZodNumber;
+    providerId: z.ZodString;
+    model: z.ZodString;
+    options: z.ZodObject<{
+        providerId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodString>;
+        maxSpeakers: z.ZodOptional<z.ZodNumber>;
+        keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        diarizer: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            ours: "ours";
+        }>>;
+    }, z.core.$strict>;
+    state: z.ZodEnum<{
+        complete: "complete";
+        failed: "failed";
+        processing: "processing";
+        queued: "queued";
+    }>;
+    isCurrent: z.ZodBoolean;
+    languages: z.ZodArray<z.ZodString>;
+    diarized: z.ZodBoolean;
+    diarization: z.ZodNullable<z.ZodEnum<{
+        none: "none";
+        ours: "ours";
+        provider: "provider";
+        tracks: "tracks";
+    }>>;
+    audioMilliseconds: z.ZodNumber;
+    segmentCount: z.ZodNumber;
+    costUsd: z.ZodNullable<z.ZodNumber>;
+    requestedBySubjectId: z.ZodString;
+    errorCode: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    completedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type RecordingTranscriptVersion = z.infer<typeof RecordingTranscriptVersion>;
+export declare const Recording: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    ownerSubjectId: z.ZodString;
+    visibility: z.ZodEnum<{
+        private: "private";
+        workspace: "workspace";
+    }>;
+    title: z.ZodString;
+    purpose: z.ZodEnum<{
+        browser: "browser";
+        dictation: "dictation";
+        meeting: "meeting";
+    }>;
+    state: z.ZodEnum<{
+        capturing: "capturing";
+        failed: "failed";
+        processing: "processing";
+        ready: "ready";
+    }>;
+    errorCode: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodString;
+    captureEndedAt: z.ZodNullable<z.ZodString>;
+    durationMilliseconds: z.ZodNumber;
+    externalRef: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    audioDeletedAt: z.ZodNullable<z.ZodString>;
+    transcription: z.ZodObject<{
+        providerId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodString>;
+        maxSpeakers: z.ZodOptional<z.ZodNumber>;
+        keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        diarizer: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            ours: "ours";
+        }>>;
+    }, z.core.$strict>;
+    tracks: z.ZodArray<z.ZodObject<{
+        trackNumber: z.ZodNumber;
+        kind: z.ZodEnum<{
+            audio: "audio";
+            video: "video";
+        }>;
+        source: z.ZodEnum<{
+            browser_tab: "browser_tab";
+            microphone: "microphone";
+            mixed: "mixed";
+            system: "system";
+            upload: "upload";
+        }>;
+        mimeType: z.ZodString;
+        chunkCount: z.ZodNumber;
+        totalBytes: z.ZodNumber;
+        durationMilliseconds: z.ZodNumber;
+        playable: z.ZodBoolean;
+        video: z.ZodNullable<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            frameCount: z.ZodNumber;
+        }, z.core.$strip>>;
+        live: z.ZodNullable<z.ZodObject<{
+            providerId: z.ZodString;
+            model: z.ZodString;
+            streamedMilliseconds: z.ZodNumber;
+            costUsd: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    transcript: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        recordingId: z.ZodString;
+        versionNumber: z.ZodNumber;
+        providerId: z.ZodString;
+        model: z.ZodString;
+        options: z.ZodObject<{
+            providerId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            maxSpeakers: z.ZodOptional<z.ZodNumber>;
+            keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            diarizer: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                ours: "ours";
+            }>>;
+        }, z.core.$strict>;
+        state: z.ZodEnum<{
+            complete: "complete";
+            failed: "failed";
+            processing: "processing";
+            queued: "queued";
+        }>;
+        isCurrent: z.ZodBoolean;
+        languages: z.ZodArray<z.ZodString>;
+        diarized: z.ZodBoolean;
+        diarization: z.ZodNullable<z.ZodEnum<{
+            none: "none";
+            ours: "ours";
+            provider: "provider";
+            tracks: "tracks";
+        }>>;
+        audioMilliseconds: z.ZodNumber;
+        segmentCount: z.ZodNumber;
+        costUsd: z.ZodNullable<z.ZodNumber>;
+        requestedBySubjectId: z.ZodString;
+        errorCode: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    sourceWorkspace: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Recording = z.infer<typeof Recording>;
+export declare const ListRecordingsResponse: z.ZodObject<{
+    recordings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        ownerSubjectId: z.ZodString;
+        visibility: z.ZodEnum<{
+            private: "private";
+            workspace: "workspace";
+        }>;
+        title: z.ZodString;
+        purpose: z.ZodEnum<{
+            browser: "browser";
+            dictation: "dictation";
+            meeting: "meeting";
+        }>;
+        state: z.ZodEnum<{
+            capturing: "capturing";
+            failed: "failed";
+            processing: "processing";
+            ready: "ready";
+        }>;
+        errorCode: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodString;
+        captureEndedAt: z.ZodNullable<z.ZodString>;
+        durationMilliseconds: z.ZodNumber;
+        externalRef: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        audioDeletedAt: z.ZodNullable<z.ZodString>;
+        transcription: z.ZodObject<{
+            providerId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            maxSpeakers: z.ZodOptional<z.ZodNumber>;
+            keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            diarizer: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                ours: "ours";
+            }>>;
+        }, z.core.$strict>;
+        tracks: z.ZodArray<z.ZodObject<{
+            trackNumber: z.ZodNumber;
+            kind: z.ZodEnum<{
+                audio: "audio";
+                video: "video";
+            }>;
+            source: z.ZodEnum<{
+                browser_tab: "browser_tab";
+                microphone: "microphone";
+                mixed: "mixed";
+                system: "system";
+                upload: "upload";
+            }>;
+            mimeType: z.ZodString;
+            chunkCount: z.ZodNumber;
+            totalBytes: z.ZodNumber;
+            durationMilliseconds: z.ZodNumber;
+            playable: z.ZodBoolean;
+            video: z.ZodNullable<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+                frameCount: z.ZodNumber;
+            }, z.core.$strip>>;
+            live: z.ZodNullable<z.ZodObject<{
+                providerId: z.ZodString;
+                model: z.ZodString;
+                streamedMilliseconds: z.ZodNumber;
+                costUsd: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        transcript: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            recordingId: z.ZodString;
+            versionNumber: z.ZodNumber;
+            providerId: z.ZodString;
+            model: z.ZodString;
+            options: z.ZodObject<{
+                providerId: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                language: z.ZodOptional<z.ZodString>;
+                maxSpeakers: z.ZodOptional<z.ZodNumber>;
+                keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                diarizer: z.ZodOptional<z.ZodEnum<{
+                    auto: "auto";
+                    ours: "ours";
+                }>>;
+            }, z.core.$strict>;
+            state: z.ZodEnum<{
+                complete: "complete";
+                failed: "failed";
+                processing: "processing";
+                queued: "queued";
+            }>;
+            isCurrent: z.ZodBoolean;
+            languages: z.ZodArray<z.ZodString>;
+            diarized: z.ZodBoolean;
+            diarization: z.ZodNullable<z.ZodEnum<{
+                none: "none";
+                ours: "ours";
+                provider: "provider";
+                tracks: "tracks";
+            }>>;
+            audioMilliseconds: z.ZodNumber;
+            segmentCount: z.ZodNumber;
+            costUsd: z.ZodNullable<z.ZodNumber>;
+            requestedBySubjectId: z.ZodString;
+            errorCode: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodString;
+            completedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        sourceWorkspace: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    nextBefore: z.ZodNullable<z.ZodObject<{
+        startedAt: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListRecordingsResponse = z.infer<typeof ListRecordingsResponse>;
+export declare const FinalizeRecordingResponse: z.ZodObject<{
+    recording: z.ZodObject<{
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        ownerSubjectId: z.ZodString;
+        visibility: z.ZodEnum<{
+            private: "private";
+            workspace: "workspace";
+        }>;
+        title: z.ZodString;
+        purpose: z.ZodEnum<{
+            browser: "browser";
+            dictation: "dictation";
+            meeting: "meeting";
+        }>;
+        state: z.ZodEnum<{
+            capturing: "capturing";
+            failed: "failed";
+            processing: "processing";
+            ready: "ready";
+        }>;
+        errorCode: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodString;
+        captureEndedAt: z.ZodNullable<z.ZodString>;
+        durationMilliseconds: z.ZodNumber;
+        externalRef: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        audioDeletedAt: z.ZodNullable<z.ZodString>;
+        transcription: z.ZodObject<{
+            providerId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            maxSpeakers: z.ZodOptional<z.ZodNumber>;
+            keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            diarizer: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                ours: "ours";
+            }>>;
+        }, z.core.$strict>;
+        tracks: z.ZodArray<z.ZodObject<{
+            trackNumber: z.ZodNumber;
+            kind: z.ZodEnum<{
+                audio: "audio";
+                video: "video";
+            }>;
+            source: z.ZodEnum<{
+                browser_tab: "browser_tab";
+                microphone: "microphone";
+                mixed: "mixed";
+                system: "system";
+                upload: "upload";
+            }>;
+            mimeType: z.ZodString;
+            chunkCount: z.ZodNumber;
+            totalBytes: z.ZodNumber;
+            durationMilliseconds: z.ZodNumber;
+            playable: z.ZodBoolean;
+            video: z.ZodNullable<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+                frameCount: z.ZodNumber;
+            }, z.core.$strip>>;
+            live: z.ZodNullable<z.ZodObject<{
+                providerId: z.ZodString;
+                model: z.ZodString;
+                streamedMilliseconds: z.ZodNumber;
+                costUsd: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        transcript: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            recordingId: z.ZodString;
+            versionNumber: z.ZodNumber;
+            providerId: z.ZodString;
+            model: z.ZodString;
+            options: z.ZodObject<{
+                providerId: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                language: z.ZodOptional<z.ZodString>;
+                maxSpeakers: z.ZodOptional<z.ZodNumber>;
+                keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                diarizer: z.ZodOptional<z.ZodEnum<{
+                    auto: "auto";
+                    ours: "ours";
+                }>>;
+            }, z.core.$strict>;
+            state: z.ZodEnum<{
+                complete: "complete";
+                failed: "failed";
+                processing: "processing";
+                queued: "queued";
+            }>;
+            isCurrent: z.ZodBoolean;
+            languages: z.ZodArray<z.ZodString>;
+            diarized: z.ZodBoolean;
+            diarization: z.ZodNullable<z.ZodEnum<{
+                none: "none";
+                ours: "ours";
+                provider: "provider";
+                tracks: "tracks";
+            }>>;
+            audioMilliseconds: z.ZodNumber;
+            segmentCount: z.ZodNumber;
+            costUsd: z.ZodNullable<z.ZodNumber>;
+            requestedBySubjectId: z.ZodString;
+            errorCode: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodString;
+            completedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        sourceWorkspace: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    transcript: z.ZodObject<{
+        id: z.ZodString;
+        recordingId: z.ZodString;
+        versionNumber: z.ZodNumber;
+        providerId: z.ZodString;
+        model: z.ZodString;
+        options: z.ZodObject<{
+            providerId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            maxSpeakers: z.ZodOptional<z.ZodNumber>;
+            keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            diarizer: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                ours: "ours";
+            }>>;
+        }, z.core.$strict>;
+        state: z.ZodEnum<{
+            complete: "complete";
+            failed: "failed";
+            processing: "processing";
+            queued: "queued";
+        }>;
+        isCurrent: z.ZodBoolean;
+        languages: z.ZodArray<z.ZodString>;
+        diarized: z.ZodBoolean;
+        diarization: z.ZodNullable<z.ZodEnum<{
+            none: "none";
+            ours: "ours";
+            provider: "provider";
+            tracks: "tracks";
+        }>>;
+        audioMilliseconds: z.ZodNumber;
+        segmentCount: z.ZodNumber;
+        costUsd: z.ZodNullable<z.ZodNumber>;
+        requestedBySubjectId: z.ZodString;
+        errorCode: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FinalizeRecordingResponse = z.infer<typeof FinalizeRecordingResponse>;
+export declare const ListRecordingTranscriptVersionsResponse: z.ZodObject<{
+    versions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        recordingId: z.ZodString;
+        versionNumber: z.ZodNumber;
+        providerId: z.ZodString;
+        model: z.ZodString;
+        options: z.ZodObject<{
+            providerId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            maxSpeakers: z.ZodOptional<z.ZodNumber>;
+            keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            diarizer: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                ours: "ours";
+            }>>;
+        }, z.core.$strict>;
+        state: z.ZodEnum<{
+            complete: "complete";
+            failed: "failed";
+            processing: "processing";
+            queued: "queued";
+        }>;
+        isCurrent: z.ZodBoolean;
+        languages: z.ZodArray<z.ZodString>;
+        diarized: z.ZodBoolean;
+        diarization: z.ZodNullable<z.ZodEnum<{
+            none: "none";
+            ours: "ours";
+            provider: "provider";
+            tracks: "tracks";
+        }>>;
+        audioMilliseconds: z.ZodNumber;
+        segmentCount: z.ZodNumber;
+        costUsd: z.ZodNullable<z.ZodNumber>;
+        requestedBySubjectId: z.ZodString;
+        errorCode: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListRecordingTranscriptVersionsResponse = z.infer<typeof ListRecordingTranscriptVersionsResponse>;
+export declare const RecordingPerson: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    memberSubjectId: z.ZodNullable<z.ZodString>;
+    email: z.ZodNullable<z.ZodString>;
+    externalRef: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    voice: z.ZodNullable<z.ZodObject<{
+        consent: z.ZodEnum<{
+            attested: "attested";
+            self: "self";
+        }>;
+        consentedAt: z.ZodString;
+        learned: z.ZodBoolean;
+        updatedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RecordingPerson = z.infer<typeof RecordingPerson>;
+export declare const ListRecordingPeopleResponse: z.ZodObject<{
+    people: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        memberSubjectId: z.ZodNullable<z.ZodString>;
+        email: z.ZodNullable<z.ZodString>;
+        externalRef: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        voice: z.ZodNullable<z.ZodObject<{
+            consent: z.ZodEnum<{
+                attested: "attested";
+                self: "self";
+            }>;
+            consentedAt: z.ZodString;
+            learned: z.ZodBoolean;
+            updatedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListRecordingPeopleResponse = z.infer<typeof ListRecordingPeopleResponse>;
+export declare const RecordingSpeaker: z.ZodObject<{
+    label: z.ZodString;
+    name: z.ZodString;
+    personId: z.ZodNullable<z.ZodString>;
+    source: z.ZodNullable<z.ZodEnum<{
+        carried_over: "carried_over";
+        confirmed: "confirmed";
+        suggested: "suggested";
+        track: "track";
+    }>>;
+    confidence: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type RecordingSpeaker = z.infer<typeof RecordingSpeaker>;
+/**
+ * True when a recording's microphone is the person recording it: computer
+ * or tab audio sits beside it, so everyone else is on that track. A
+ * microphone alone (a phone, a room) may hear several people.
+ */
+export declare function recordingMicrophoneIsOwner(tracks: readonly {
+    source: RecordingTrackSource;
+}[]): boolean;
+/** What an unnamed speaker label stands for, for clients that word it in the reader's language. */
+export type RecordingSpeakerDefault = {
+    kind: "speaker";
+    number: number;
+} | {
+    kind: "microphone";
+} | {
+    kind: "system";
+} | {
+    kind: "track";
+    number: number;
+} | {
+    kind: "label";
+    label: string;
+};
+/**
+ * What a speaker label stands for until someone names it: the diarizer's
+ * `speaker_1` (or `t0_speaker_1`) is speaker 2, and a whole-track label such as
+ * `track-0` is that track's microphone, shared audio or plain track number.
+ */
+export declare function recordingSpeakerDefault(label: string, tracks: readonly {
+    trackNumber: number;
+    source: RecordingTrackSource;
+}[]): RecordingSpeakerDefault;
+/**
+ * The name a speaker label has until someone names it: "Speaker 2" for a
+ * diarizer's `speaker_1` (or `t0_speaker_1` when several tracks were
+ * diarized), and the track's role for a whole-track label such as `track-0`.
+ * Servers and clients both use this, so the same voice reads the same
+ * everywhere.
+ */
+export declare function defaultRecordingSpeakerName(label: string, tracks: readonly {
+    trackNumber: number;
+    source: RecordingTrackSource;
+}[]): string;
+export declare const UpdateRecordingSpeakersResponse: z.ZodObject<{
+    speakers: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        name: z.ZodString;
+        personId: z.ZodNullable<z.ZodString>;
+        source: z.ZodNullable<z.ZodEnum<{
+            carried_over: "carried_over";
+            confirmed: "confirmed";
+            suggested: "suggested";
+            track: "track";
+        }>>;
+        confidence: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UpdateRecordingSpeakersResponse = z.infer<typeof UpdateRecordingSpeakersResponse>;
+export declare const RecordingTranscriptSegment: z.ZodObject<{
+    index: z.ZodNumber;
+    startMilliseconds: z.ZodNumber;
+    endMilliseconds: z.ZodNumber;
+    trackNumber: z.ZodNullable<z.ZodNumber>;
+    speakerLabel: z.ZodNullable<z.ZodString>;
+    text: z.ZodString;
+    edited: z.ZodBoolean;
+}, z.core.$strip>;
+export type RecordingTranscriptSegment = z.infer<typeof RecordingTranscriptSegment>;
+export declare const UpdateRecordingSegmentsResponse: z.ZodObject<{
+    segments: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        startMilliseconds: z.ZodNumber;
+        endMilliseconds: z.ZodNumber;
+        trackNumber: z.ZodNullable<z.ZodNumber>;
+        speakerLabel: z.ZodNullable<z.ZodString>;
+        text: z.ZodString;
+        edited: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UpdateRecordingSegmentsResponse = z.infer<typeof UpdateRecordingSegmentsResponse>;
+export declare const RecordingTranscriptPage: z.ZodObject<{
+    version: z.ZodObject<{
+        id: z.ZodString;
+        recordingId: z.ZodString;
+        versionNumber: z.ZodNumber;
+        providerId: z.ZodString;
+        model: z.ZodString;
+        options: z.ZodObject<{
+            providerId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            maxSpeakers: z.ZodOptional<z.ZodNumber>;
+            keyterms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            diarizer: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                ours: "ours";
+            }>>;
+        }, z.core.$strict>;
+        state: z.ZodEnum<{
+            complete: "complete";
+            failed: "failed";
+            processing: "processing";
+            queued: "queued";
+        }>;
+        isCurrent: z.ZodBoolean;
+        languages: z.ZodArray<z.ZodString>;
+        diarized: z.ZodBoolean;
+        diarization: z.ZodNullable<z.ZodEnum<{
+            none: "none";
+            ours: "ours";
+            provider: "provider";
+            tracks: "tracks";
+        }>>;
+        audioMilliseconds: z.ZodNumber;
+        segmentCount: z.ZodNumber;
+        costUsd: z.ZodNullable<z.ZodNumber>;
+        requestedBySubjectId: z.ZodString;
+        errorCode: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    speakers: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        name: z.ZodString;
+        personId: z.ZodNullable<z.ZodString>;
+        source: z.ZodNullable<z.ZodEnum<{
+            carried_over: "carried_over";
+            confirmed: "confirmed";
+            suggested: "suggested";
+            track: "track";
+        }>>;
+        confidence: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    segments: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        startMilliseconds: z.ZodNumber;
+        endMilliseconds: z.ZodNumber;
+        trackNumber: z.ZodNullable<z.ZodNumber>;
+        speakerLabel: z.ZodNullable<z.ZodString>;
+        text: z.ZodString;
+        edited: z.ZodBoolean;
+    }, z.core.$strip>>;
+    nextAfter: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type RecordingTranscriptPage = z.infer<typeof RecordingTranscriptPage>;
+/** A short-lived link to one track's prepared audio, for playback. */
+export declare const RecordingTrackAudio: z.ZodObject<{
+    url: z.ZodString;
+    expiresAt: z.ZodString;
+    mimeType: z.ZodString;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type RecordingTrackAudio = z.infer<typeof RecordingTrackAudio>;
+export declare const RecordingTranscriptionCapabilities: z.ZodObject<{
+    batch: z.ZodBoolean;
+    live: z.ZodBoolean;
+    diarization: z.ZodBoolean;
+    liveDiarization: z.ZodBoolean;
+    multichannel: z.ZodBoolean;
+    maxSpeakers: z.ZodNullable<z.ZodNumber>;
+    wordTimestamps: z.ZodBoolean;
+    languages: z.ZodArray<z.ZodString>;
+    languageDetection: z.ZodBoolean;
+    keyterms: z.ZodBoolean;
+    speakerLibrary: z.ZodBoolean;
+    maxDurationSeconds: z.ZodNullable<z.ZodNumber>;
+    maxFileBytes: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type RecordingTranscriptionCapabilities = z.infer<typeof RecordingTranscriptionCapabilities>;
+/**
+ * Who pays for a speech-to-text model: the workspace's own provider key
+ * (`workspace_key`), a subscription the workspace signed in to, which
+ * Opengeni never charges (`workspace_subscription`), or an account the
+ * deployment holds, charged in Opengeni credits where credit billing is on
+ * (`deployment`).
+ */
+export declare const RecordingTranscriptionFunding: z.ZodEnum<{
+    deployment: "deployment";
+    workspace_key: "workspace_key";
+    workspace_subscription: "workspace_subscription";
+}>;
+export type RecordingTranscriptionFunding = z.infer<typeof RecordingTranscriptionFunding>;
+export declare const RecordingTranscriptionModel: z.ZodObject<{
+    providerId: z.ZodString;
+    providerName: z.ZodString;
+    model: z.ZodString;
+    name: z.ZodString;
+    available: z.ZodBoolean;
+    funding: z.ZodEnum<{
+        deployment: "deployment";
+        workspace_key: "workspace_key";
+        workspace_subscription: "workspace_subscription";
+    }>;
+    capabilities: z.ZodObject<{
+        batch: z.ZodBoolean;
+        live: z.ZodBoolean;
+        diarization: z.ZodBoolean;
+        liveDiarization: z.ZodBoolean;
+        multichannel: z.ZodBoolean;
+        maxSpeakers: z.ZodNullable<z.ZodNumber>;
+        wordTimestamps: z.ZodBoolean;
+        languages: z.ZodArray<z.ZodString>;
+        languageDetection: z.ZodBoolean;
+        keyterms: z.ZodBoolean;
+        speakerLibrary: z.ZodBoolean;
+        maxDurationSeconds: z.ZodNullable<z.ZodNumber>;
+        maxFileBytes: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    usdPerHour: z.ZodNullable<z.ZodNumber>;
+    chargedInCredits: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RecordingTranscriptionModel = z.infer<typeof RecordingTranscriptionModel>;
+export declare const ListRecordingModelsResponse: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        providerId: z.ZodString;
+        providerName: z.ZodString;
+        model: z.ZodString;
+        name: z.ZodString;
+        available: z.ZodBoolean;
+        funding: z.ZodEnum<{
+            deployment: "deployment";
+            workspace_key: "workspace_key";
+            workspace_subscription: "workspace_subscription";
+        }>;
+        capabilities: z.ZodObject<{
+            batch: z.ZodBoolean;
+            live: z.ZodBoolean;
+            diarization: z.ZodBoolean;
+            liveDiarization: z.ZodBoolean;
+            multichannel: z.ZodBoolean;
+            maxSpeakers: z.ZodNullable<z.ZodNumber>;
+            wordTimestamps: z.ZodBoolean;
+            languages: z.ZodArray<z.ZodString>;
+            languageDetection: z.ZodBoolean;
+            keyterms: z.ZodBoolean;
+            speakerLibrary: z.ZodBoolean;
+            maxDurationSeconds: z.ZodNullable<z.ZodNumber>;
+            maxFileBytes: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        usdPerHour: z.ZodNullable<z.ZodNumber>;
+        chargedInCredits: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    default: z.ZodObject<{
+        providerId: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strip>;
+    dictationDefault: z.ZodNullable<z.ZodObject<{
+        providerId: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strip>>;
+    pinned: z.ZodBoolean;
+    language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    liveTranscript: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ListRecordingModelsResponse = z.infer<typeof ListRecordingModelsResponse>;
+/**
+ * The wire protocols a live transcription session can speak. Clients connect
+ * to the provider directly with a short-lived grant from the API, so the
+ * workspace's provider key never leaves the server.
+ *
+ * `elevenlabs.scribe_realtime`: JSON over WebSocket. The client sends
+ * `{"message_type":"input_audio_chunk","audio_base_64":…,"commit":false,"sample_rate":…}`
+ * with little-endian 16-bit mono PCM; the provider answers with
+ * `partial_transcript` and `committed_transcript_with_timestamps` messages.
+ *
+ * `openai.realtime`: an OpenAI Realtime transcription session (OpenAI or
+ * Azure OpenAI), already configured. `token` is a short-lived client secret,
+ * sent as `Authorization: Bearer <token>`. A browser posts its WebRTC offer
+ * (`application/sdp`) to `webrtcUrl`, sends the track's audio as media and
+ * reads events on a data channel named `oai-events`. A client that can set
+ * headers on a WebSocket (React Native) opens `url` instead and sends
+ * `{"type":"input_audio_buffer.append","audio":…}` with base64 PCM at
+ * `audio.sampleRate`. Either way the provider answers with
+ * `input_audio_buffer.speech_started`/`speech_stopped` (with `audio_start_ms`
+ * and `audio_end_ms`) and
+ * `conversation.item.input_audio_transcription.delta`/`completed` events.
+ */
+export declare const RecordingLiveProtocol: z.ZodEnum<{
+    "elevenlabs.scribe_realtime": "elevenlabs.scribe_realtime";
+    "openai.realtime": "openai.realtime";
+}>;
+export type RecordingLiveProtocol = z.infer<typeof RecordingLiveProtocol>;
+/** Ask for a live transcription session for one track of a recording being captured. */
+export declare const CreateRecordingLiveSessionRequest: z.ZodObject<{
+    trackNumber: z.ZodNumber;
+    providerId: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CreateRecordingLiveSessionRequest = z.infer<typeof CreateRecordingLiveSessionRequest>;
+/**
+ * A grant to stream one track to a live model. Connect before `expiresAt`,
+ * and ask for a new session to reconnect. For `elevenlabs.scribe_realtime`,
+ * `url` carries the single-use credential and the audio format; for
+ * `openai.realtime`, the credential is `token` (see {@link RecordingLiveProtocol}).
+ */
+export declare const RecordingLiveSession: z.ZodObject<{
+    providerId: z.ZodString;
+    model: z.ZodString;
+    protocol: z.ZodEnum<{
+        "elevenlabs.scribe_realtime": "elevenlabs.scribe_realtime";
+        "openai.realtime": "openai.realtime";
+    }>;
+    url: z.ZodString;
+    token: z.ZodOptional<z.ZodString>;
+    webrtcUrl: z.ZodOptional<z.ZodString>;
+    audio: z.ZodObject<{
+        encoding: z.ZodLiteral<"pcm_s16le">;
+        sampleRate: z.ZodNumber;
+    }, z.core.$strip>;
+    expiresAt: z.ZodString;
+}, z.core.$strip>;
+export type RecordingLiveSession = z.infer<typeof RecordingLiveSession>;
+/**
+ * A finished stretch of live text on one track. Times are from the start of
+ * the recording. Live segments are a preview: they are removed once the
+ * recording's first transcript is ready.
+ */
+export declare const RecordingLiveSegment: z.ZodObject<{
+    trackNumber: z.ZodNumber;
+    segmentNumber: z.ZodNumber;
+    startMilliseconds: z.ZodNumber;
+    endMilliseconds: z.ZodNumber;
+    text: z.ZodString;
+    sequence: z.ZodNumber;
+}, z.core.$strip>;
+export type RecordingLiveSegment = z.infer<typeof RecordingLiveSegment>;
+/**
+ * Save finished live text for one track. Sending a segment number again
+ * keeps the first copy, so a recorder can retry freely.
+ */
+export declare const AppendRecordingLiveSegmentsRequest: z.ZodObject<{
+    trackNumber: z.ZodNumber;
+    streamedMilliseconds: z.ZodNumber;
+    segments: z.ZodArray<z.ZodObject<{
+        segmentNumber: z.ZodNumber;
+        startMilliseconds: z.ZodNumber;
+        endMilliseconds: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AppendRecordingLiveSegmentsRequest = z.infer<typeof AppendRecordingLiveSegmentsRequest>;
+export declare const ListRecordingLiveSegmentsResponse: z.ZodObject<{
+    segments: z.ZodArray<z.ZodObject<{
+        trackNumber: z.ZodNumber;
+        segmentNumber: z.ZodNumber;
+        startMilliseconds: z.ZodNumber;
+        endMilliseconds: z.ZodNumber;
+        text: z.ZodString;
+        sequence: z.ZodNumber;
+    }, z.core.$strip>>;
+    after: z.ZodNumber;
+    ended: z.ZodBoolean;
+}, z.core.$strip>;
+export type ListRecordingLiveSegmentsResponse = z.infer<typeof ListRecordingLiveSegmentsResponse>;
+/**
+ * A meeting's two Markdown documents. `notepad` is what people jot down
+ * while it is recorded; `notes` is the written-up summary, decisions and
+ * action items, by a person or an agent, afterwards.
+ */
+export declare const RECORDING_NOTE_KINDS: readonly ["notepad", "notes"];
+export declare const RecordingNoteKind: z.ZodEnum<{
+    notepad: "notepad";
+    notes: "notes";
+}>;
+export type RecordingNoteKind = z.infer<typeof RecordingNoteKind>;
+/** Notes can hold about 50 pages of text. */
+export declare const RECORDING_NOTE_MAX_BYTES = 262144;
+export declare const RecordingNote: z.ZodObject<{
+    kind: z.ZodEnum<{
+        notepad: "notepad";
+        notes: "notes";
+    }>;
+    body: z.ZodString;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodString;
+    updatedBy: z.ZodObject<{
+        subjectId: z.ZodString;
+        sessionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RecordingNote = z.infer<typeof RecordingNote>;
+export declare const ListRecordingNotesResponse: z.ZodObject<{
+    notes: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            notepad: "notepad";
+            notes: "notes";
+        }>;
+        body: z.ZodString;
+        revision: z.ZodNumber;
+        updatedAt: z.ZodString;
+        updatedBy: z.ZodObject<{
+            subjectId: z.ZodString;
+            sessionId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListRecordingNotesResponse = z.infer<typeof ListRecordingNotesResponse>;
+/**
+ * Replace one of a meeting's notes. With `expectedRevision`, the save is
+ * refused (409 `notes_changed`) when someone saved a newer revision first;
+ * 0 means "nobody has written it yet". Without it, the save always wins.
+ */
+export declare const SaveRecordingNoteRequest: z.ZodObject<{
+    body: z.ZodString;
+    expectedRevision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type SaveRecordingNoteRequest = z.infer<typeof SaveRecordingNoteRequest>;
+export declare const RECORDING_EVENT_TYPES: readonly ["recording.started", "recording.finished", "recording.transcript.ready", "recording.transcript.failed", "recording.transcript.current_changed", "recording.speakers.updated", "recording.notes.updated", "recording.deleted"];
+export type RecordingEventType = (typeof RECORDING_EVENT_TYPES)[number];
+/**
+ * The `data` of a recording webhook event. Events carry ids, states and
+ * numbers only, never a title, audio or transcript text, so a receiver reads
+ * the recording through the API with its own authority.
+ */
+export type RecordingEventData = {
+    recordingId: string;
+    ownerSubjectId: string;
+    visibility: RecordingVisibility;
+    externalRef: string | null;
+    state: RecordingState;
+    durationMilliseconds?: number;
+    versionId?: string;
+    versionNumber?: number;
+    providerId?: string;
+    model?: string;
+    segmentCount?: number;
+    languages?: string[];
+    errorCode?: string | null;
+    previousVersionId?: string | null;
+    /** `recording.notes.updated`: which notes, their new revision, and the chat whose agent saved them. */
+    noteKind?: RecordingNoteKind;
+    noteRevision?: number;
+    sessionId?: string | null;
+};
+/** Limits of durable (chunked, resumable) dictation, advertised in client config. */
+export declare const ClientResumableVoiceInputConfig: z.ZodObject<{
+    maxDurationSeconds: z.ZodNumber;
+    maxSizeBytes: z.ZodNumber;
+    maxChunkSizeBytes: z.ZodNumber;
+    providerSegmentSeconds: z.ZodNumber;
+}, z.core.$strict>;
+export type ClientResumableVoiceInputConfig = z.infer<typeof ClientResumableVoiceInputConfig>;
+/** Audio is sent to a transcription provider in segments of at most this length. */
+export declare const TRANSCRIPTION_PROVIDER_SEGMENT_SECONDS = 50;