assemblyai 2.0.0-beta → 2.0.1

package/dist/index.js

@@ -1,8 +1,26 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var axios = require('axios');
 var WebSocket = require('ws');
-var fs = require('fs/promises');
+var promises = require('fs/promises');
+
+function createAxiosClient(params) {
+    const client = axios.create({
+        baseURL: params.baseUrl,
+        headers: { Authorization: params.apiKey },
+    });
+    client.interceptors.response.use(undefined, throwApiError);
+    return client;
+}
+function throwApiError(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);
+}
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -49,7 +67,7 @@ class BaseService {
     }
 }
 
-class LeMURService extends BaseService {
+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);
@@ -80,8 +98,8 @@ var RealtimeErrorType;
 (function (RealtimeErrorType) {
     RealtimeErrorType[RealtimeErrorType["BadSampleRate"] = 4000] = "BadSampleRate";
     RealtimeErrorType[RealtimeErrorType["AuthFailed"] = 4001] = "AuthFailed";
-    RealtimeErrorType[RealtimeErrorType["InsufficientFunds"] = 4002] = "InsufficientFunds";
-    RealtimeErrorType[RealtimeErrorType["FreeAccount"] = 4003] = "FreeAccount";
+    // Both InsufficientFunds and FreeAccount error use 4002
+    RealtimeErrorType[RealtimeErrorType["InsufficientFundsOrFreeAccount"] = 4002] = "InsufficientFundsOrFreeAccount";
     RealtimeErrorType[RealtimeErrorType["NonexistentSessionId"] = 4004] = "NonexistentSessionId";
     RealtimeErrorType[RealtimeErrorType["SessionExpired"] = 4008] = "SessionExpired";
     RealtimeErrorType[RealtimeErrorType["ClosedSession"] = 4010] = "ClosedSession";
@@ -99,8 +117,7 @@ var 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.InsufficientFundsOrFreeAccount]: "Insufficient funds or you are using a free account. 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",
@@ -116,94 +133,164 @@ const RealtimeErrorMessages = {
     [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);
-    }
 }
 
+const defaultRealtimeUrl = "wss://api.assemblyai.com/v2/realtime/ws";
 class RealtimeService {
     constructor(params) {
+        var _a, _b, _c;
         this.listeners = {};
-        this.params = params;
-    }
-    connectionUrl(connectionParams) {
-        if (!this.params.baseUrl) {
-            throw new Error("Missing base URL");
+        this.realtimeUrl = (_a = params.realtimeUrl) !== null && _a !== void 0 ? _a : defaultRealtimeUrl;
+        this.sampleRate = (_b = params.sampleRate) !== null && _b !== void 0 ? _b : 16000;
+        this.wordBoost = params.wordBoost;
+        this.realtimeUrl = (_c = params.realtimeUrl) !== null && _c !== void 0 ? _c : defaultRealtimeUrl;
+        if ("apiKey" in params)
+            this.apiKey = params.apiKey;
+        if ("token" in params)
+            this.token = params.token;
+        if (!(this.apiKey || this.token)) {
+            throw new Error("API key or temporary token is required.");
         }
-        const url = new URL(this.params.baseUrl);
+    }
+    connectionUrl() {
+        const url = new URL(this.realtimeUrl);
         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(","));
+        if (this.token) {
+            searchParams.set("token", this.token);
+        }
+        searchParams.set("sample_rate", this.sampleRate.toString());
+        if (this.wordBoost && this.wordBoost.length > 0) {
+            searchParams.set("word_boost", JSON.stringify(this.wordBoost));
+        }
         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,
-            },
+    connect() {
+        return new Promise((resolve, _) => {
+            if (this.socket) {
+                throw new Error("Already connected");
+            }
+            const url = this.connectionUrl();
+            let headers;
+            if (this.token) {
+                headers = undefined;
+            }
+            else if (this.apiKey) {
+                headers = { Authorization: this.apiKey };
+            }
+            this.socket = new WebSocket(url.toString(), { headers });
+            this.socket.onclose = ({ code, reason }) => {
+                var _a, _b;
+                if (!reason) {
+                    if (code in RealtimeErrorType) {
+                        reason = RealtimeErrorMessages[code];
+                    }
+                }
+                (_b = (_a = this.listeners).close) === null || _b === void 0 ? void 0 : _b.call(_a, code, reason);
+            };
+            this.socket.onerror = (errorEvent) => {
+                var _a, _b, _c, _d;
+                if (errorEvent.error)
+                    (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, errorEvent.error);
+                else
+                    (_d = (_c = this.listeners).error) === null || _d === void 0 ? void 0 : _d.call(_c, new Error(errorEvent.message));
+            };
+            this.socket.onmessage = ({ data }) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+                const message = JSON.parse(data.toString());
+                if ("error" in message) {
+                    (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, new RealtimeError(message.error));
+                    return;
+                }
+                switch (message.message_type) {
+                    case "SessionBegins": {
+                        const openObject = {
+                            sessionId: message.session_id,
+                            expiresAt: new Date(message.expires_at),
+                        };
+                        resolve(openObject);
+                        (_d = (_c = this.listeners).open) === null || _d === void 0 ? void 0 : _d.call(_c, openObject);
+                        break;
+                    }
+                    case "PartialTranscript": {
+                        // message.created is actually a string when coming from the socket
+                        message.created = new Date(message.created);
+                        (_f = (_e = this.listeners).transcript) === null || _f === void 0 ? void 0 : _f.call(_e, message);
+                        (_h = (_g = this.listeners)["transcript.partial"]) === null || _h === void 0 ? void 0 : _h.call(_g, message);
+                        break;
+                    }
+                    case "FinalTranscript": {
+                        // message.created is actually a string when coming from the socket
+                        message.created = new Date(message.created);
+                        (_k = (_j = this.listeners).transcript) === null || _k === void 0 ? void 0 : _k.call(_j, message);
+                        (_m = (_l = this.listeners)["transcript.final"]) === null || _m === void 0 ? void 0 : _m.call(_l, message);
+                        break;
+                    }
+                    case "SessionTerminated": {
+                        (_o = this.sessionTerminatedResolve) === null || _o === void 0 ? void 0 : _o.call(this);
+                        break;
+                    }
+                }
+            };
         });
-        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) {
+    sendAudio(audio) {
         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"),
+            audio_data: Buffer.from(audio).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, }) {
+    close(waitForSessionTermination = true) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.client.get(`/v2/transcript/${transcript_id}/${format}`);
-            return data;
+            if (this.socket) {
+                if (this.socket.readyState === WebSocket.OPEN) {
+                    const terminateSessionMessage = `{"terminate_session": true}`;
+                    if (waitForSessionTermination) {
+                        const sessionTerminatedPromise = new Promise((resolve, _) => {
+                            this.sessionTerminatedResolve = resolve;
+                        });
+                        this.socket.send(terminateSessionMessage);
+                        yield sessionTerminatedPromise;
+                    }
+                    else {
+                        this.socket.send(terminateSessionMessage);
+                    }
+                }
+                this.socket.removeAllListeners();
+                this.socket.close();
+            }
+            this.listeners = {};
+            this.socket = undefined;
         });
     }
 }
 
-class TranscriptRedactionService extends BaseService {
-    retrieve(params) {
+class RealtimeServiceFactory {
+    constructor(client, params) {
+        this.client = client;
+        this.params = params;
+    }
+    createService(params) {
+        if (!params)
+            params = { apiKey: this.params.apiKey };
+        else if (!("token" in params) && !params.apiKey) {
+            params.apiKey = this.params.apiKey;
+        }
+        return new RealtimeService(params);
+    }
+    createTemporaryToken(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.client.get(`/v2/transcript/${params.transcript_id}/redacted-audio`);
-            return data;
+            const response = yield this.client.post("/v2/realtime/token", params);
+            return response.data.token;
         });
     }
 }
@@ -212,13 +299,15 @@ 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,
-    }) {
+    /**
+     * Create a transcript.
+     * @param params The parameters to create a transcript.
+     * @param options The options used for creating the new transcript.
+     * @returns A promise that resolves to the newly created transcript.
+     */
+    create(params, options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const path = getPath(params.audio_url);
             if (path !== null) {
@@ -226,23 +315,24 @@ class TranscriptService extends BaseService {
                 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);
+            if ((_a = options === null || options === void 0 ? void 0 : options.poll) !== null && _a !== void 0 ? _a : true) {
+                return yield this.poll(res.data.id, options);
             }
             return res.data;
         });
     }
-    poll(transcriptId, settings) {
+    poll(transcriptId, options) {
+        var _a;
         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)) {
+                const transcript = yield this.get(transcriptId);
+                if (transcript.status === "completed" || transcript.status === "error") {
                     return transcript;
                 }
-                else if (Date.now() - startTime < pollingTimeout) {
-                    yield new Promise((resolve) => setTimeout(resolve, pollingInterval));
+                else if (Date.now() - startTime <
+                    ((_a = options === null || options === void 0 ? void 0 : options.pollingTimeout) !== null && _a !== void 0 ? _a : 180000)) {
+                    yield new Promise((resolve) => { var _a; return setTimeout(resolve, (_a = options === null || options === void 0 ? void 0 : options.pollingInterval) !== null && _a !== void 0 ? _a : 3000); });
                 }
                 else {
                     throw new Error("Polling timeout");
@@ -250,22 +340,40 @@ class TranscriptService extends BaseService {
             }
         });
     }
-    retrieve(id) {
+    /**
+     * Retrieve a transcript.
+     * @param id The identifier of the transcript.
+     * @returns A promise that resolves to the transcript.
+     */
+    get(id) {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.client.get(`/v2/transcript/${id}`);
             return res.data;
         });
     }
+    // TODO: add options overload to support list querystring parameters
+    /**
+     * Retrieves a paged list of transcript listings.
+     * @param nextUrl The URL to retrieve the transcript list from. If not provided, the first page will be retrieved.
+     * @returns
+     */
     list(nextUrl) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.client.get(nextUrl || "/v2/transcript");
+            const { data } = yield this.client.get(nextUrl !== null && nextUrl !== void 0 ? nextUrl : "/v2/transcript");
             for (const transcriptListItem of data.transcripts) {
                 transcriptListItem.created = new Date(transcriptListItem.created);
-                transcriptListItem.completed = new Date(transcriptListItem.completed);
+                if (transcriptListItem.completed) {
+                    transcriptListItem.completed = new Date(transcriptListItem.completed);
+                }
             }
             return data;
         });
     }
+    /**
+     * Delete a transcript
+     * @param id The identifier of the transcript.
+     * @returns A promise that resolves to the transcript.
+     */
     delete(id) {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.client.delete(`/v2/transcript/${id}`);
@@ -273,35 +381,48 @@ class TranscriptService extends BaseService {
         });
     }
     /**
-     * Retrieve all segments of a transcript.
+     * Retrieve all sentences 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.
+     * @return A promise that resolves to the sentences.
      */
-    segments(id, type) {
+    sentences(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.client.get(`/v2/transcript/${id}/${type}`);
+            const { data } = yield this.client.get(`/v2/transcript/${id}/sentences`);
             return data;
         });
     }
     /**
-     * Retrieve all sentences of a transcript.
+     * Retrieve all paragraphs of a transcript.
      * @param id The identifier of the transcript.
-     * @return A promise that resolves to the sentences.
+     * @return A promise that resolves to the paragraphs.
      */
-    sentences(id) {
+    paragraphs(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(`/v2/transcript/${id}/paragraphs`);
+            return data;
+        });
+    }
+    /**
+     * Retrieve subtitles of a transcript.
+     * @param id The identifier of the transcript.
+     * @param format The format of the subtitles.
+     * @return A promise that resolves to the subtitles text.
+     */
+    subtitles(id, format = "srt") {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.segments(id, "sentences");
+            const { data } = yield this.client.get(`/v2/transcript/${id}/${format}`);
+            return data;
         });
     }
     /**
-     * Retrieve all paragraphs of a transcript.
+     * Retrieve redactions of a transcript.
      * @param id The identifier of the transcript.
-     * @return A promise that resolves to the paragraphs.
+     * @return A promise that resolves to the subtitles text.
      */
-    paragraphs(id) {
+    redactions(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.segments(id, "paragraphs");
+            const { data } = yield this.client.get(`/v2/transcript/${id}/redacted-audio`);
+            return data;
         });
     }
 }
@@ -327,7 +448,7 @@ class FileService extends BaseService {
      */
     upload(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            const file = yield fs.readFile(path);
+            const file = yield promises.readFile(path);
             const { data } = yield this.client.post("/v2/upload", file, {
                 headers: {
                     "Content-Type": "application/octet-stream",
@@ -341,40 +462,21 @@ class FileService extends BaseService {
 class AssemblyAI {
     /**
      * Create a new AssemblyAI client.
-     * @param params The parameters for the service, including the API token and base URL, if any.
+     * @param params The parameters for the service, including the API key and base URL, if any.
      */
     constructor(params) {
         params.baseUrl = params.baseUrl || "https://api.assemblyai.com";
-        const client = this.createClient(params);
+        const client = createAxiosClient(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;
+        this.lemur = new LemurService(client);
+        this.realtime = new RealtimeServiceFactory(client, params);
     }
 }
 
-module.exports = AssemblyAI;
+exports.FileService = FileService;
+exports.LemurService = LemurService;
+exports.RealtimeService = RealtimeService;
+exports.RealtimeServiceFactory = RealtimeServiceFactory;
+exports.TranscriptService = TranscriptService;
+exports.default = AssemblyAI;

package/dist/services/base.d.ts

@@ -1,5 +1,4 @@
 import { AxiosInstance } from "axios";
-import { BaseServiceParams } from "@/types";
 /**
  * Base class for services that communicate with the API.
  */
@@ -11,5 +10,4 @@ declare abstract class BaseService {
      */
     constructor(client: AxiosInstance);
 }
-export type { BaseServiceParams };
 export default BaseService;

package/dist/services/index.d.ts

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

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

@@ -1,8 +1,8 @@
-import { LeMURResponse, SummaryParams, QuestionAnswerParams, ActionItemsParams, TaskParams, LeMURQuestionAnswerResponse } from "@/types";
+import { LemurSummaryParameters, LemurActionItemsParameters, LemurQuestionAnswerParameters, LemurTaskParameters, LemurSummaryResponse, LemurQuestionAnswerResponse, LemurActionItemsResponse, LemurTaskResponse } 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>;
+export default class LemurService extends BaseService {
+    summary(params: LemurSummaryParameters): Promise<LemurSummaryResponse>;
+    questionAnswer(params: LemurQuestionAnswerParameters): Promise<LemurQuestionAnswerResponse>;
+    actionItems(params: LemurActionItemsParameters): Promise<LemurActionItemsResponse>;
+    task(params: LemurTaskParameters): Promise<LemurTaskResponse>;
 }

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

@@ -0,0 +1,10 @@
+import { BaseServiceParams, RealtimeTokenParams, CreateRealtimeServiceParams } from "@/types";
+import { AxiosInstance } from "axios";
+import { RealtimeService } from "./service";
+export declare class RealtimeServiceFactory {
+    private client;
+    private params;
+    constructor(client: AxiosInstance, params: BaseServiceParams);
+    createService(params?: CreateRealtimeServiceParams): RealtimeService;
+    createTemporaryToken(params: RealtimeTokenParams): Promise<string>;
+}

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

@@ -1,16 +1,2 @@
-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;
-}
+export * from "@/services/realtime/factory";
+export * from "@/services/realtime/service";

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

@@ -0,0 +1,22 @@
+import { RealtimeServiceParams, RealtimeTranscript, PartialTranscript, FinalTranscript, SessionBeginsEventData } from "@/types";
+export declare class RealtimeService {
+    private realtimeUrl;
+    private sampleRate;
+    private wordBoost?;
+    private apiKey?;
+    private token?;
+    private socket?;
+    private listeners;
+    private sessionTerminatedResolve?;
+    constructor(params: RealtimeServiceParams);
+    private connectionUrl;
+    on(event: "open", listener: (event: SessionBeginsEventData) => void): void;
+    on(event: "transcript", listener: (transcript: RealtimeTranscript) => void): void;
+    on(event: "transcript.partial", listener: (transcript: PartialTranscript) => void): void;
+    on(event: "transcript.final", listener: (transcript: FinalTranscript) => void): void;
+    on(event: "error", listener: (error: Error) => void): void;
+    on(event: "close", listener: (code: number, reason: string) => void): void;
+    connect(): Promise<SessionBeginsEventData>;
+    sendAudio(audio: ArrayBuffer): void;
+    close(waitForSessionTermination?: boolean): Promise<void>;
+}