assemblyai 1.0.0 → 2.0.0-beta

package/dist/index.js

@@ -0,0 +1,380 @@
+'use strict';
+
+var axios = require('axios');
+var WebSocket = require('ws');
+var fs = require('fs/promises');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Base class for services that communicate with the API.
+ */
+class BaseService {
+    /**
+     * Create a new service.
+     * @param params The AxiosInstance to send HTTP requests to the API.
+     */
+    constructor(client) {
+        this.client = client;
+    }
+}
+
+class LeMURService extends BaseService {
+    summary(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.post("/lemur/v3/generate/summary", params);
+            return data;
+        });
+    }
+    questionAnswer(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.post("/lemur/v3/generate/question-answer", params);
+            return data;
+        });
+    }
+    actionItems(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.post("/lemur/v3/generate/action-items", params);
+            return data;
+        });
+    }
+    task(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.post("/lemur/v3/generate/task", params);
+            return data;
+        });
+    }
+}
+
+var RealtimeErrorType;
+(function (RealtimeErrorType) {
+    RealtimeErrorType[RealtimeErrorType["BadSampleRate"] = 4000] = "BadSampleRate";
+    RealtimeErrorType[RealtimeErrorType["AuthFailed"] = 4001] = "AuthFailed";
+    RealtimeErrorType[RealtimeErrorType["InsufficientFunds"] = 4002] = "InsufficientFunds";
+    RealtimeErrorType[RealtimeErrorType["FreeAccount"] = 4003] = "FreeAccount";
+    RealtimeErrorType[RealtimeErrorType["NonexistentSessionId"] = 4004] = "NonexistentSessionId";
+    RealtimeErrorType[RealtimeErrorType["SessionExpired"] = 4008] = "SessionExpired";
+    RealtimeErrorType[RealtimeErrorType["ClosedSession"] = 4010] = "ClosedSession";
+    RealtimeErrorType[RealtimeErrorType["RateLimited"] = 4029] = "RateLimited";
+    RealtimeErrorType[RealtimeErrorType["UniqueSessionViolation"] = 4030] = "UniqueSessionViolation";
+    RealtimeErrorType[RealtimeErrorType["SessionTimeout"] = 4031] = "SessionTimeout";
+    RealtimeErrorType[RealtimeErrorType["AudioTooShort"] = 4032] = "AudioTooShort";
+    RealtimeErrorType[RealtimeErrorType["AudioTooLong"] = 4033] = "AudioTooLong";
+    RealtimeErrorType[RealtimeErrorType["BadJson"] = 4100] = "BadJson";
+    RealtimeErrorType[RealtimeErrorType["BadSchema"] = 4101] = "BadSchema";
+    RealtimeErrorType[RealtimeErrorType["TooManyStreams"] = 4102] = "TooManyStreams";
+    RealtimeErrorType[RealtimeErrorType["Reconnected"] = 4103] = "Reconnected";
+    RealtimeErrorType[RealtimeErrorType["ReconnectAttemptsExhausted"] = 1013] = "ReconnectAttemptsExhausted";
+})(RealtimeErrorType || (RealtimeErrorType = {}));
+const RealtimeErrorMessages = {
+    [RealtimeErrorType.BadSampleRate]: "Sample rate must be a positive integer",
+    [RealtimeErrorType.AuthFailed]: "Not Authorized",
+    [RealtimeErrorType.InsufficientFunds]: "Insufficient funds",
+    [RealtimeErrorType.FreeAccount]: "This feature is paid-only and requires you to add a credit card. Please visit https://assemblyai.com/dashboard/ to add a credit card to your account",
+    [RealtimeErrorType.NonexistentSessionId]: "Session ID does not exist",
+    [RealtimeErrorType.SessionExpired]: "Session has expired",
+    [RealtimeErrorType.ClosedSession]: "Session is closed",
+    [RealtimeErrorType.RateLimited]: "Rate limited",
+    [RealtimeErrorType.UniqueSessionViolation]: "Unique session violation",
+    [RealtimeErrorType.SessionTimeout]: "Session Timeout",
+    [RealtimeErrorType.AudioTooShort]: "Audio too short",
+    [RealtimeErrorType.AudioTooLong]: "Audio too long",
+    [RealtimeErrorType.BadJson]: "Bad JSON",
+    [RealtimeErrorType.BadSchema]: "Bad schema",
+    [RealtimeErrorType.TooManyStreams]: "Too many streams",
+    [RealtimeErrorType.Reconnected]: "Reconnected",
+    [RealtimeErrorType.ReconnectAttemptsExhausted]: "Reconnect attempts exhausted",
+};
+class RealtimeError extends Error {
+    constructor(code) {
+        const message = RealtimeErrorMessages[code];
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+class RealtimeService {
+    constructor(params) {
+        this.listeners = {};
+        this.params = params;
+    }
+    connectionUrl(connectionParams) {
+        if (!this.params.baseUrl) {
+            throw new Error("Missing base URL");
+        }
+        const url = new URL(this.params.baseUrl);
+        if (url.protocol !== "wss:") {
+            throw new Error("Invalid protocol, must be wss");
+        }
+        const searchParams = new URLSearchParams();
+        searchParams.set("sample_rate", connectionParams.sampleRate.toString());
+        searchParams.set("word_boost", connectionParams.wordBoost.join(","));
+        url.search = searchParams.toString();
+        return url;
+    }
+    on(event, listener) {
+        this.listeners[event] = listener;
+    }
+    connect(connectionParams) {
+        if (this.socket) {
+            throw new Error("Already connected");
+        }
+        const url = this.connectionUrl(Object.assign(Object.assign({}, connectionParams), { sampleRate: connectionParams.sampleRate || 16000, wordBoost: connectionParams.wordBoost || [] }));
+        this.socket = new WebSocket(url.toString(), {
+            headers: {
+                Authorization: this.params.token,
+            },
+        });
+        this.socket.onopen = () => { var _a, _b; return (_b = (_a = this.listeners).open) === null || _b === void 0 ? void 0 : _b.call(_a); };
+        this.socket.onclose = ({ code, reason }) => { var _a, _b; return (_b = (_a = this.listeners).close) === null || _b === void 0 ? void 0 : _b.call(_a, code, reason); };
+        this.socket.onerror = (error) => {
+            var _a, _b;
+            const code = error.message;
+            const realtimeError = new RealtimeError(code);
+            (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, realtimeError);
+        };
+        this.socket.onmessage = ({ data }) => {
+            var _a, _b;
+            const message = JSON.parse(data.toString());
+            (_b = (_a = this.listeners).data) === null || _b === void 0 ? void 0 : _b.call(_a, message);
+        };
+    }
+    send(data) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error("Socket is not open for communication");
+        }
+        const payload = {
+            audio_data: Buffer.from(data).toString("base64"),
+        };
+        this.socket.send(JSON.stringify(payload));
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        this.listeners = {};
+        this.socket = undefined;
+    }
+}
+
+class TranscriptSubtitleService extends BaseService {
+    retrieve({ transcript_id, format, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(`/v2/transcript/${transcript_id}/${format}`);
+            return data;
+        });
+    }
+}
+
+class TranscriptRedactionService extends BaseService {
+    retrieve(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(`/v2/transcript/${params.transcript_id}/redacted-audio`);
+            return data;
+        });
+    }
+}
+
+class TranscriptService extends BaseService {
+    constructor(client, files) {
+        super(client);
+        this.files = files;
+        this.subtitles = new TranscriptSubtitleService(client);
+        this.redactions = new TranscriptRedactionService(client);
+    }
+    create(params, settings = {
+        pollingInterval: 3000,
+        pollingTimeout: 180000,
+    }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = getPath(params.audio_url);
+            if (path !== null) {
+                const uploadUrl = yield this.files.upload(path);
+                params.audio_url = uploadUrl;
+            }
+            const res = yield this.client.post("/v2/transcript", params);
+            if (settings && settings.pollingInterval) {
+                return yield this.poll(res.data.id, settings);
+            }
+            return res.data;
+        });
+    }
+    poll(transcriptId, settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pollingInterval, pollingTimeout, resolver = (t) => t.status === "completed" || t.status === "error", } = settings;
+            const startTime = Date.now();
+            while (true) {
+                const transcript = yield this.retrieve(transcriptId);
+                if (resolver(transcript)) {
+                    return transcript;
+                }
+                else if (Date.now() - startTime < pollingTimeout) {
+                    yield new Promise((resolve) => setTimeout(resolve, pollingInterval));
+                }
+                else {
+                    throw new Error("Polling timeout");
+                }
+            }
+        });
+    }
+    retrieve(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.get(`/v2/transcript/${id}`);
+            return res.data;
+        });
+    }
+    list(nextUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(nextUrl || "/v2/transcript");
+            for (const transcriptListItem of data.transcripts) {
+                transcriptListItem.created = new Date(transcriptListItem.created);
+                transcriptListItem.completed = new Date(transcriptListItem.completed);
+            }
+            return data;
+        });
+    }
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.delete(`/v2/transcript/${id}`);
+            return res.data;
+        });
+    }
+    /**
+     * Retrieve all segments of a transcript.
+     * @param id The identifier of the transcript.
+     * @param type The type of segment to retrieve.
+     * @return A promise that resolves to the retrieved resource.
+     */
+    segments(id, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(`/v2/transcript/${id}/${type}`);
+            return data;
+        });
+    }
+    /**
+     * Retrieve all sentences of a transcript.
+     * @param id The identifier of the transcript.
+     * @return A promise that resolves to the sentences.
+     */
+    sentences(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.segments(id, "sentences");
+        });
+    }
+    /**
+     * Retrieve all paragraphs of a transcript.
+     * @param id The identifier of the transcript.
+     * @return A promise that resolves to the paragraphs.
+     */
+    paragraphs(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.segments(id, "paragraphs");
+        });
+    }
+}
+function getPath(path) {
+    let url;
+    try {
+        url = new URL(path);
+        if (url.protocol === "file:")
+            return url.pathname;
+        else
+            return null;
+    }
+    catch (_a) {
+        return path;
+    }
+}
+
+class FileService extends BaseService {
+    /**
+     * Upload a local file to AssemblyAI.
+     * @param path The local file to upload.
+     * @return A promise that resolves to the uploaded file URL.
+     */
+    upload(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = yield fs.readFile(path);
+            const { data } = yield this.client.post("/v2/upload", file, {
+                headers: {
+                    "Content-Type": "application/octet-stream",
+                },
+            });
+            return data.upload_url;
+        });
+    }
+}
+
+class AssemblyAI {
+    /**
+     * Create a new AssemblyAI client.
+     * @param params The parameters for the service, including the API token and base URL, if any.
+     */
+    constructor(params) {
+        params.baseUrl = params.baseUrl || "https://api.assemblyai.com";
+        const client = this.createClient(params);
+        this.files = new FileService(client);
+        this.transcripts = new TranscriptService(client, this.files);
+        this.lemur = new LeMURService(client);
+        this.realtime = ({ baseUrl } = { baseUrl: "" }) => {
+            if (!baseUrl) {
+                const url = new URL(params.baseUrl);
+                url.protocol = "wss:";
+                baseUrl = url.toString();
+            }
+            return new RealtimeService({
+                token: params.token,
+                baseUrl,
+            });
+        };
+    }
+    createClient(params) {
+        const client = axios.create({
+            baseURL: params.baseUrl,
+            headers: { Authorization: params.token },
+        });
+        client.interceptors.response.use(null, (error) => {
+            var _a, _b;
+            if (axios.isAxiosError(error) && ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error)) {
+                return Promise.reject(new Error(error.response.data.error));
+            }
+            return Promise.reject(error);
+        });
+        return client;
+    }
+}
+
+module.exports = AssemblyAI;

package/dist/services/base.d.ts

@@ -0,0 +1,15 @@
+import { AxiosInstance } from "axios";
+import { BaseServiceParams } from "@/types";
+/**
+ * Base class for services that communicate with the API.
+ */
+declare abstract class BaseService {
+    protected client: AxiosInstance;
+    /**
+     * Create a new service.
+     * @param params The AxiosInstance to send HTTP requests to the API.
+     */
+    constructor(client: AxiosInstance);
+}
+export type { BaseServiceParams };
+export default BaseService;

package/dist/services/files/index.d.ts

@@ -0,0 +1,9 @@
+import BaseService from "@/services/base";
+export default class FileService extends BaseService {
+    /**
+     * Upload a local file to AssemblyAI.
+     * @param path The local file to upload.
+     * @return A promise that resolves to the uploaded file URL.
+     */
+    upload(path: string): Promise<string>;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,31 @@
+import { BaseServiceParams } from "./base";
+import LeMURService from "./lemur";
+import RealtimeService from "./realtime";
+import TranscriptService from "./transcripts";
+import FileService from "./files";
+export default class AssemblyAI {
+    /**
+     * The files service.
+     */
+    files: FileService;
+    /**
+     * The transcripts service.
+     */
+    transcripts: TranscriptService;
+    /**
+     * The LeMUR service.
+     */
+    lemur: LeMURService;
+    /**
+     * The realtime service.
+     */
+    realtime: (params?: {
+        baseUrl: string;
+    }) => RealtimeService;
+    /**
+     * Create a new AssemblyAI client.
+     * @param params The parameters for the service, including the API token and base URL, if any.
+     */
+    constructor(params: BaseServiceParams);
+    private createClient;
+}

package/dist/services/lemur/index.d.ts

@@ -0,0 +1,8 @@
+import { LeMURResponse, SummaryParams, QuestionAnswerParams, ActionItemsParams, TaskParams, LeMURQuestionAnswerResponse } from "@/types";
+import BaseService from "@/services/base";
+export default class LeMURService extends BaseService {
+    summary(params: SummaryParams): Promise<LeMURResponse>;
+    questionAnswer(params: QuestionAnswerParams): Promise<LeMURQuestionAnswerResponse>;
+    actionItems(params: ActionItemsParams): Promise<LeMURResponse>;
+    task(params: TaskParams): Promise<LeMURResponse>;
+}

package/dist/services/realtime/index.d.ts

@@ -0,0 +1,16 @@
+import { BaseServiceParams } from "@/services/base";
+import { Connectable, RealtimeConnectionParams, RealtimeTranscript } from "@/types";
+export default class RealtimeService implements Connectable<RealtimeTranscript, RealtimeConnectionParams> {
+    private params;
+    private socket?;
+    private listeners;
+    constructor(params: BaseServiceParams);
+    private connectionUrl;
+    on(event: "data", listener: (transcript: RealtimeTranscript) => void): void;
+    on(event: "error", listener: (error: Error) => void): void;
+    on(event: "open", listener: () => void): void;
+    on(event: "close", listener: (code: number, reason: string) => void): void;
+    connect(connectionParams: RealtimeConnectionParams): void;
+    send(data: ArrayBuffer): void;
+    disconnect(): void;
+}

package/dist/services/transcripts/index.d.ts

@@ -0,0 +1,42 @@
+import BaseService from "@/services/base";
+import TranscriptSubtitleService from "./subtitles";
+import { ParagraphsBody, SentencesBody, Transcript, TranscriptList, TranscriptParams, TranscriptPollingSettings, Createable, Deletable, Listable, Retrieveable } from "@/types";
+import TranscriptRedactionService from "./redactions";
+import { AxiosInstance } from "axios";
+import FileService from "../files";
+export default class TranscriptService extends BaseService implements Createable<Transcript, TranscriptParams, TranscriptPollingSettings>, Retrieveable<Transcript>, Deletable<Transcript>, Listable<TranscriptList> {
+    private files;
+    /**
+     * The subtitles service.
+     */
+    subtitles: TranscriptSubtitleService;
+    /**
+     * The redactions service.
+     */
+    redactions: TranscriptRedactionService;
+    constructor(client: AxiosInstance, files: FileService);
+    create(params: TranscriptParams, settings?: TranscriptPollingSettings | null): Promise<Transcript>;
+    private poll;
+    retrieve(id: string): Promise<Transcript>;
+    list(nextUrl?: string): Promise<TranscriptList>;
+    delete(id: string): Promise<Transcript>;
+    /**
+     * Retrieve all segments of a transcript.
+     * @param id The identifier of the transcript.
+     * @param type The type of segment to retrieve.
+     * @return A promise that resolves to the retrieved resource.
+     */
+    private segments;
+    /**
+     * Retrieve all sentences of a transcript.
+     * @param id The identifier of the transcript.
+     * @return A promise that resolves to the sentences.
+     */
+    sentences(id: string): Promise<SentencesBody>;
+    /**
+     * Retrieve all paragraphs of a transcript.
+     * @param id The identifier of the transcript.
+     * @return A promise that resolves to the paragraphs.
+     */
+    paragraphs(id: string): Promise<ParagraphsBody>;
+}

package/dist/services/transcripts/redactions.d.ts

@@ -0,0 +1,14 @@
+import BaseService from "@/services/base";
+import { Retrieveable } from "@/types";
+type TranscriptRedactionParams = {
+    transcript_id: string;
+    path: string;
+};
+type TranscriptRedactionResponse = {
+    status: "redacted_audio_ready";
+    redacted_audio_url: string;
+};
+export default class TranscriptRedactionService extends BaseService implements Retrieveable<TranscriptRedactionResponse, TranscriptRedactionParams> {
+    retrieve(params: TranscriptRedactionParams): Promise<TranscriptRedactionResponse>;
+}
+export {};

package/dist/services/transcripts/subtitles.d.ts

@@ -0,0 +1,12 @@
+import BaseService from "@/services/base";
+import { Retrieveable } from "@/types";
+type Subtitle = string;
+type SubtitleFormat = "vtt" | "srt";
+type TranscriptionSubtitleParams = {
+    transcript_id: string;
+    format: SubtitleFormat;
+};
+export default class TranscriptSubtitleService extends BaseService implements Retrieveable<Subtitle, TranscriptionSubtitleParams> {
+    retrieve({ transcript_id, format, }: TranscriptionSubtitleParams): Promise<Subtitle>;
+}
+export {};

package/dist/types/core/index.d.ts

@@ -0,0 +1,2 @@
+export type * from "./transcript";
+export type * from "./segments";

package/dist/types/core/params.d.ts

@@ -0,0 +1,2 @@
+type WordBoostWeight = "low" | "default" | "high";
+export type { WordBoostWeight };

package/dist/types/core/segments.d.ts

@@ -0,0 +1,28 @@
+type SegmentType = "paragraphs" | "sentences";
+type Segment<T> = T & {
+    id: string;
+    confidence: number;
+    audio_duration: number;
+};
+type ParagraphsBody = Segment<{
+    paragraphs: Utterance[];
+}>;
+type SentencesBody = Segment<{
+    sentences: Utterance[];
+}>;
+type Word = {
+    text: string;
+    start: number;
+    end: number;
+    confidence: number;
+    speaker?: string | null;
+};
+type Utterance = {
+    start: number;
+    end: number;
+    confidence: number;
+    speaker?: string;
+    text: string;
+    words: Word[];
+};
+export type { Word, Utterance, ParagraphsBody, SentencesBody, SegmentType };

package/dist/types/core/transcript.d.ts

@@ -0,0 +1,113 @@
+import { AutoChapter, AutoHighlights, ContentSafetyLabels, Entity, PIIAudioQuality, PIIRedactionPolicies, SentimentAnalysis, SummaryModel, SummaryType, TopicDetection } from "@/types/models";
+import { PageDetails } from "@/types/shared";
+import { Utterance, Word } from "./segments";
+import { WordBoostWeight } from "./params";
+type TranscriptStatus = "queued" | "processing" | "completed" | "error";
+type TranscriptBase = {
+    status?: TranscriptStatus | null;
+    audio_url: string;
+    audio_start_from?: number | null;
+    audio_end_at?: number | null;
+    filter_profanity?: boolean;
+    custom_spelling?: null;
+    disfluencies?: boolean;
+    dual_channel?: boolean | null;
+    punctuate?: boolean;
+    speaker_labels?: boolean;
+    format_text?: boolean;
+    auto_chapters?: boolean;
+    content_safety?: boolean;
+    entity_detection?: boolean;
+    language_code?: string;
+    language_detection?: boolean;
+    iab_categories?: boolean;
+    auto_highlights?: boolean;
+    summarization?: boolean;
+    summary_type?: SummaryType;
+    summary_model?: SummaryModel;
+    redact_pii?: boolean;
+    redact_pii_sub?: string;
+    redact_pii_audio_quality?: PIIAudioQuality;
+    redact_pii_audio?: boolean;
+    redact_pii_policies?: PIIRedactionPolicies[];
+    sentiment_analysis?: boolean;
+    webhook_auth_header_name?: null;
+    webhook_auth?: boolean;
+    webhook_status_code?: null | number;
+    webhook_url?: null | string;
+    word_boost?: string[];
+    boost_param?: WordBoostWeight;
+};
+type TranscriptParams = Omit<TranscriptBase, "status">;
+type TranscriptQueued = TranscriptBase & {
+    id: string;
+    status: "queued";
+};
+type TranscriptProcessing = TranscriptBase & {
+    id: string;
+    status: "processing";
+};
+type TranscriptCompleted = TranscriptBase & {
+    status: "completed";
+    id: string;
+    audio_duration?: number;
+    words?: Word[];
+    utterances?: Utterance[];
+    text?: string;
+    confidence?: number;
+    chapters?: AutoChapter[] | null;
+    content_safety_labels?: ContentSafetyLabels;
+    entities?: Entity[];
+    iab_categories_result?: TopicDetection;
+    auto_highlights_result?: AutoHighlights;
+    summary?: string;
+    sentiment_analysis_results?: SentimentAnalysis[];
+    /**
+     * @deprecated Acoustic Model is deprecated and will be removed in a future release
+     */
+    acoustic_model?: unknown;
+    /**
+     * @deprecated Speed Boost is deprecated and will be removed in a future release
+     */
+    speed_boost?: boolean;
+    /**
+     * @deprecated Language Model is deprecated and will be removed in a future release
+     */
+    language_model?: unknown;
+};
+type TranscriptFailed = TranscriptBase & {
+    status: "error";
+    id: string;
+    error?: string;
+};
+type Transcript = Readonly<TranscriptQueued> | Readonly<TranscriptProcessing> | Readonly<TranscriptCompleted> | Readonly<TranscriptFailed>;
+type TranscriptPollingSettings = {
+    pollingInterval: number;
+    pollingTimeout: number;
+    resolver?: (transcript: Transcript) => boolean;
+};
+type TranscriptListInternal = {
+    page_details: PageDetails;
+    transcripts: TranscriptListItemInternal[];
+};
+type TranscriptListItemInternal = {
+    id: string;
+    resource_url: string;
+    status: TranscriptStatus;
+    created: string;
+    completed: string;
+    audio_url: string;
+};
+type TranscriptList = {
+    page_details: PageDetails;
+    transcripts: TranscriptListItem[];
+};
+type TranscriptListItem = {
+    id: string;
+    resource_url: string;
+    status: TranscriptStatus;
+    created: Date;
+    completed: Date;
+    audio_url: string;
+};
+export type { Transcript, TranscriptStatus, TranscriptParams, TranscriptList, TranscriptListItem, TranscriptListInternal, TranscriptListItemInternal, TranscriptPollingSettings, };