@fonoster/apiserver 0.6.2 → 0.7.0

package/dist/voice/handlers/utils/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./awaitForPlaybackFinished"), exports);
+__exportStar(require("./awaitForRecordingFinished"), exports);
+__exportStar(require("./isDtmf"), exports);

package/dist/voice/handlers/utils/isDtmf.d.ts

@@ -0,0 +1,2 @@
+declare function isDtmf(digit: string): boolean;
+export { isDtmf };

package/dist/voice/handlers/utils/isDtmf.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDtmf = isDtmf;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function isDtmf(digit) {
+    return /^[0-9*#]+$/.test(digit);
+}

package/dist/voice/integrations/findIntegrationsCredentials.d.ts

@@ -1,3 +1,3 @@
 import { IntegrationConfig } from "./types";
-declare function findIntegrationsCredentials(integrations: IntegrationConfig[], engine: string): IntegrationConfig;
+declare function findIntegrationsCredentials(integrations: IntegrationConfig[], engine: string): Record<string, unknown>;
 export { findIntegrationsCredentials };

package/dist/voice/integrations/findIntegrationsCredentials.js

@@ -2,5 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findIntegrationsCredentials = findIntegrationsCredentials;
 function findIntegrationsCredentials(integrations, engine) {
-    return integrations.find((i) => i.productRef === engine);
+    var _a;
+    return (_a = integrations.find((i) => i.productRef === engine)) === null || _a === void 0 ? void 0 : _a.credentials;
 }

package/dist/voice/integrations/getSttConfig.d.ts

@@ -2,7 +2,9 @@ import { VoiceLanguage } from "@fonoster/common";
 import { Application } from "@fonoster/types";
 import { IntegrationConfig } from "./types";
 declare function getSttConfig(integrations: IntegrationConfig[], app: Application): {
-    credentials: IntegrationConfig;
-    languageCode: VoiceLanguage;
+    config: {
+        languageCode: VoiceLanguage;
+    };
+    credentials: Record<string, unknown>;
 };
 export { getSttConfig };

package/dist/voice/integrations/getSttConfig.js

@@ -5,5 +5,8 @@ const findIntegrationsCredentials_1 = require("./findIntegrationsCredentials");
 function getSttConfig(integrations, app) {
     const config = app.speechToText.config;
     const credentials = (0, findIntegrationsCredentials_1.findIntegrationsCredentials)(integrations, app.speechToText.productRef);
-    return Object.assign(Object.assign({}, config), { credentials });
+    return {
+        config,
+        credentials
+    };
 }

package/dist/voice/integrations/getTtsConfig.d.ts

@@ -1,7 +1,8 @@
 import { Application } from "@fonoster/types";
 import { IntegrationConfig } from "./types";
 declare function getTtsConfig(integrations: IntegrationConfig[], app: Application): {
-    credentials: IntegrationConfig;
+    config: Record<string, unknown>;
+    credentials: Record<string, unknown>;
     pathToFiles: string;
 };
 export { getTtsConfig };

package/dist/voice/integrations/getTtsConfig.js

@@ -6,5 +6,9 @@ const envs_1 = require("../../envs");
 function getTtsConfig(integrations, app) {
     const config = app.textToSpeech.config;
     const credentials = (0, findIntegrationsCredentials_1.findIntegrationsCredentials)(integrations, app.textToSpeech.productRef);
-    return Object.assign(Object.assign({}, config), { credentials, pathToFiles: envs_1.TTS_PATH_TO_FILES });
+    return {
+        config,
+        credentials,
+        pathToFiles: envs_1.TTS_PATH_TO_FILES
+    };
 }

package/dist/voice/integrations/makeCreateContainer.js

@@ -80,7 +80,7 @@ function makeCreateContainer(prisma, pathToIntegrations) {
         return {
             ref: appRef,
             accessKeyId: app.accessKeyId,
-            appEndpoint: app.appEndpoint,
+            endpoint: app.endpoint,
             tts,
             stt
         };

package/dist/voice/integrations/types.d.ts

@@ -7,7 +7,7 @@ type IntegrationConfig = {
 type IntegrationsContainer = {
     ref: string;
     accessKeyId: string;
-    appEndpoint: string;
+    endpoint: string;
     tts: AbstractTextToSpeech<unknown>;
     stt: AbstractSpeechToText<unknown>;
 };

package/dist/voice/makeCreateVoiceClient.js

@@ -43,24 +43,18 @@ function makeCreateVoiceClient(createContainer) {
         const { ari, event, channel } = params;
         const { id: sessionRef, caller } = event.channel;
         const { name: callerName, number: callerNumber } = caller;
-        const getChannelVar = (0, makeGetChannelVar_1.makeGetChannelVar)(channel);
+        const getChannelVar = (0, makeGetChannelVar_1.makeGetChannelVarWithoutThrow)(channel);
         // Variables set by Asterisk's dialplan
         const appRef = (_a = (yield getChannelVar(types_1.ChannelVar.APP_REF))) === null || _a === void 0 ? void 0 : _a.value;
         const ingressNumber = ((_b = (yield getChannelVar(types_1.ChannelVar.INGRESS_NUMBER))) === null || _b === void 0 ? void 0 : _b.value) || "";
-        const { accessKeyId, appEndpoint, tts, stt } = yield createContainer(appRef);
+        const { accessKeyId, endpoint, tts, stt } = yield createContainer(appRef);
         const sessionToken = yield createToken({ accessKeyId, appRef });
-        let metadataStr;
-        try {
-            metadataStr = (_c = (yield getChannelVar(types_1.ChannelVar.METADATA))) === null || _c === void 0 ? void 0 : _c.value;
-        }
-        catch (e) {
-            // Do nothing
-        }
+        const metadataStr = (_c = (yield getChannelVar(types_1.ChannelVar.METADATA))) === null || _c === void 0 ? void 0 : _c.value;
         const config = {
             appRef,
             sessionRef,
             accessKeyId,
-            appEndpoint,
+            endpoint,
             callerName,
             callerNumber,
             ingressNumber,

package/dist/voice/makeGetChannelVar.d.ts

@@ -1,4 +1,5 @@
 import { Channel } from "ari-client";
 import { ChannelVar } from "./types";
 declare function makeGetChannelVar(channel: Channel): (variable: ChannelVar) => Promise<import("ari-client").Variable>;
-export { makeGetChannelVar };
+declare function makeGetChannelVarWithoutThrow(channel: Channel): (variable: ChannelVar) => Promise<import("ari-client").Variable>;
+export { makeGetChannelVar, makeGetChannelVarWithoutThrow };

package/dist/voice/makeGetChannelVar.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetChannelVar = makeGetChannelVar;
+exports.makeGetChannelVarWithoutThrow = makeGetChannelVarWithoutThrow;
 const ChannelVarNotFoundError_1 = require("./ChannelVarNotFoundError");
 function makeGetChannelVar(channel) {
     return (variable) => __awaiter(this, void 0, void 0, function* () {
@@ -23,3 +24,15 @@ function makeGetChannelVar(channel) {
         }
     });
 }
+function makeGetChannelVarWithoutThrow(channel) {
+    return (variable) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield channel.getChannelVar({
+                variable
+            });
+        }
+        catch (e) {
+            return null;
+        }
+    });
+}

package/dist/voice/stt/AbstractSpeechToText.d.ts

@@ -1,11 +1,12 @@
 import { Stream } from "stream";
 import * as z from "zod";
-import { SpeechResult, StreamSpeechResult, SttConfig } from "./types";
-declare abstract class AbstractSpeechToText<E, T extends SttConfig = SttConfig> {
+import { SpeechResult, StreamSpeech, SttConfig } from "./types";
+import { SpeechToText } from "../types";
+declare abstract class AbstractSpeechToText<E, T extends SttConfig = SttConfig> implements SpeechToText {
     abstract readonly engineName: E;
     config: T;
     constructor(config: T);
-    abstract streamTranscribe(stream: Stream): StreamSpeechResult;
+    abstract streamTranscribe(stream: Stream): StreamSpeech;
     abstract transcribe(stream: Stream): Promise<SpeechResult>;
     getName(): E;
     static getConfigValidationSchema(): z.Schema;

package/dist/voice/stt/Deepgram.d.ts

@@ -0,0 +1,18 @@
+import { Stream } from "stream";
+import * as z from "zod";
+import { AbstractSpeechToText } from "./AbstractSpeechToText";
+import { DeepgramSttConfig, SpeechResult, StreamSpeech } from "./types";
+import { SpeechToText } from "../types";
+declare const DeepgramClient: any;
+declare const ENGINE_NAME = "stt.deepgram";
+declare class Deepgram extends AbstractSpeechToText<typeof ENGINE_NAME> implements SpeechToText {
+    client: typeof DeepgramClient;
+    engineConfig: DeepgramSttConfig;
+    readonly engineName = "stt.deepgram";
+    constructor(config: DeepgramSttConfig);
+    streamTranscribe(stream: Stream): StreamSpeech;
+    transcribe(stream: Stream): Promise<SpeechResult>;
+    static getConfigValidationSchema(): z.Schema;
+    static getCredentialsValidationSchema(): z.Schema;
+}
+export { Deepgram, ENGINE_NAME };

package/dist/voice/stt/Deepgram.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINE_NAME = exports.Deepgram = void 0;
+/* eslint-disable @typescript-eslint/no-var-requires */
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const stream_1 = require("stream");
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const z = __importStar(require("zod"));
+const AbstractSpeechToText_1 = require("./AbstractSpeechToText");
+const types_1 = require("./types");
+const { DeepgramClient, LiveTranscriptionEvents, createClient } = require("@deepgram/sdk"); // Why Deepgram :(
+const ENGINE_NAME = "stt.deepgram";
+exports.ENGINE_NAME = ENGINE_NAME;
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class Deepgram extends AbstractSpeechToText_1.AbstractSpeechToText {
+    constructor(config) {
+        super(config);
+        this.engineName = ENGINE_NAME;
+        this.client = createClient(config.credentials.apiKey);
+        this.engineConfig = config;
+    }
+    streamTranscribe(stream) {
+        const connection = this.client.listen.live(buildTranscribeConfig(this.engineConfig.config));
+        const out = new stream_1.Stream();
+        connection.on(LiveTranscriptionEvents.Open, () => {
+            // WARNING: This is a workaround to keep the connection open while the system
+            // is playing a file which causes the stream to be paused. We need to look into why
+            // the stream is being paused.
+            const keepAliveInterval = setInterval(() => {
+                const keepAliveMsg = JSON.stringify({ type: "KeepAlive" });
+                connection.send(keepAliveMsg);
+            }, 3000);
+            stream.on("data", (chunk) => {
+                connection.send(chunk);
+            });
+            connection.on(LiveTranscriptionEvents.Transcript, (data) => {
+                if (!data.channel.alternatives[0].transcript || !data.speech_final) {
+                    return;
+                }
+                out.emit("data", {
+                    speech: data.channel.alternatives[0].transcript
+                });
+            });
+            connection.on(LiveTranscriptionEvents.Error, (err) => {
+                logger.warn("error on Deepgram connection", { err });
+                clearInterval(keepAliveInterval);
+                connection.destroy();
+            });
+        });
+        return out;
+    }
+    transcribe(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const connection = this.client.listen.live(buildTranscribeConfig(this.engineConfig.config));
+                stream.on("data", (chunk) => {
+                    connection.send(chunk);
+                });
+                connection.on(LiveTranscriptionEvents.Open, () => {
+                    connection.on(LiveTranscriptionEvents.Transcript, (data) => {
+                        if (data.channel.alternatives[0].transcript && data.speech_final) {
+                            const result = {
+                                speech: data.channel.alternatives[0].transcript,
+                                isFinal: true
+                            };
+                            resolve(result);
+                            connection.destroy();
+                        }
+                    });
+                    connection.on(LiveTranscriptionEvents.Error, (err) => {
+                        logger.warn("error on Deepgram connection", { err });
+                        reject(err);
+                    });
+                });
+                stream.on("end", () => {
+                    connection.destroy();
+                });
+                stream.on("error", (err) => {
+                    connection.destroy();
+                    reject(err);
+                });
+            });
+        });
+    }
+    static getConfigValidationSchema() {
+        return z.object({
+            languageCode: z.nativeEnum(common_1.VoiceLanguage).optional().nullable(),
+            model: z.nativeEnum(types_1.DeepgramModel).optional().nullable()
+        });
+    }
+    static getCredentialsValidationSchema() {
+        return z.object({
+            apiKey: z.string()
+        });
+    }
+}
+exports.Deepgram = Deepgram;
+function buildTranscribeConfig(config) {
+    return {
+        model: config.model || types_1.DeepgramModel.NOVA_2_PHONECALL,
+        encoding: "linear16",
+        sample_rate: 16000,
+        language: config.languageCode || common_1.VoiceLanguage.EN_US,
+        smart_format: true
+    };
+}

package/dist/voice/stt/Google.d.ts

@@ -2,16 +2,15 @@ import { Stream } from "stream";
 import { SpeechClient } from "@google-cloud/speech";
 import * as z from "zod";
 import { AbstractSpeechToText } from "./AbstractSpeechToText";
-import { GoogleSttConfig, SpeechResult, StreamSpeechResult } from "./types";
+import { GoogleSttConfig, SpeechResult, StreamSpeech } from "./types";
+import { SpeechToText } from "../types";
 declare const ENGINE_NAME = "stt.google";
-declare class Google extends AbstractSpeechToText<typeof ENGINE_NAME> {
+declare class Google extends AbstractSpeechToText<typeof ENGINE_NAME> implements SpeechToText {
     client: SpeechClient;
-    config: GoogleSttConfig;
+    engineConfig: GoogleSttConfig;
     readonly engineName = "stt.google";
-    protected readonly AUDIO_ENCODING = "LINEAR16";
-    protected readonly SAMPLE_RATE_HERTZ = 16000;
     constructor(config: GoogleSttConfig);
-    streamTranscribe(_: Stream): StreamSpeechResult;
+    streamTranscribe(_: Stream): StreamSpeech;
     transcribe(stream: Stream): Promise<SpeechResult>;
     static getConfigValidationSchema(): z.Schema;
     static getCredentialsValidationSchema(): z.Schema;

package/dist/voice/stt/Google.js

@@ -39,32 +39,32 @@ const z = __importStar(require("zod"));
 const AbstractSpeechToText_1 = require("./AbstractSpeechToText");
 const ENGINE_NAME = "stt.google";
 exports.ENGINE_NAME = ENGINE_NAME;
-const AUDIO_ENCODING = "LINEAR16";
-const SAMPLE_RATE_HERTZ = 16000;
 class Google extends AbstractSpeechToText_1.AbstractSpeechToText {
     constructor(config) {
         super(config);
         this.engineName = ENGINE_NAME;
-        this.AUDIO_ENCODING = AUDIO_ENCODING;
-        this.SAMPLE_RATE_HERTZ = SAMPLE_RATE_HERTZ;
         this.client = new speech_1.SpeechClient(config);
-        this.config = Object.assign(Object.assign({}, config), { config: {
-                encoding: AUDIO_ENCODING,
-                sampleRateHertz: SAMPLE_RATE_HERTZ,
-                interimResults: false,
-                languageCode: config.languageCode
-            } });
+        this.engineConfig = config;
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     streamTranscribe(_) {
         // Not implemented
-        return null;
+        throw new Error("Stream Transcribe not implemented for Google Engine");
     }
     transcribe(stream) {
         return __awaiter(this, void 0, void 0, function* () {
+            const languageCode = this.engineConfig.config.languageCode || common_1.VoiceLanguage.EN_US;
+            const audioConfig = {
+                interimResults: false,
+                config: {
+                    encoding: "LINEAR16",
+                    sampleRateHertz: 16000,
+                    languageCode
+                }
+            };
             return new Promise((resolve, reject) => {
                 const recognizeStream = this.client
-                    .streamingRecognize(this.config)
+                    .streamingRecognize(audioConfig)
                     .on("error", (e) => reject(e))
                     .on("data", (data) => {
                     var _a;
@@ -86,7 +86,7 @@ class Google extends AbstractSpeechToText_1.AbstractSpeechToText {
     }
     static getConfigValidationSchema() {
         return z.object({
-            languageCode: z.nativeEnum(common_1.VoiceLanguage)
+            languageCode: z.nativeEnum(common_1.VoiceLanguage).optional().nullable()
         });
     }
     static getCredentialsValidationSchema() {

package/dist/voice/stt/SpeechToTextFactory.js

@@ -20,6 +20,7 @@ exports.SpeechToTextFactory = void 0;
  * limitations under the License.
  */
 const logger_1 = require("@fonoster/logger");
+const Deepgram_1 = require("./Deepgram");
 const Google_1 = require("./Google");
 const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
 class SpeechToTextFactory {
@@ -39,3 +40,4 @@ exports.SpeechToTextFactory = SpeechToTextFactory;
 SpeechToTextFactory.engines = new Map();
 // Register engines
 SpeechToTextFactory.registerEngine(Google_1.ENGINE_NAME, Google_1.Google);
+SpeechToTextFactory.registerEngine(Deepgram_1.ENGINE_NAME, Deepgram_1.Deepgram);

package/dist/voice/stt/types.d.ts

@@ -1,20 +1,23 @@
 import { VoiceLanguage } from "@fonoster/common/src/tts/types";
-type SttConfig = {
-    languageCode: VoiceLanguage;
-};
+declare enum DeepgramModel {
+    NOVA_2 = "nova-2",
+    NOVA_2_PHONECALL = "nova-2-phonecall",
+    NOVA_2_CONVERSATIONALAI = "nova-2-conversationalai"
+}
 type SpeechResult = {
     speech: string;
     isFinal: boolean;
 };
-type StreamSpeechResult = {
+type StreamSpeech = {
     on(events: string, callback: (result: SpeechResult) => void): void;
-    close: () => void;
 };
-type GoogleSttConfig = SttConfig & {
+type SttConfig = {
+    config: {
+        languageCode: VoiceLanguage;
+    };
+};
+type GoogleSttConfig = {
     config: {
-        encoding: "LINEAR16";
-        sampleRateHertz: 16000;
-        interimResults: boolean;
         languageCode: VoiceLanguage;
     };
     credentials: {
@@ -22,4 +25,13 @@ type GoogleSttConfig = SttConfig & {
         private_key: string;
     };
 };
-export { SttConfig, SpeechResult, StreamSpeechResult, GoogleSttConfig };
+type DeepgramSttConfig = {
+    config: {
+        languageCode: VoiceLanguage;
+        model: DeepgramModel;
+    };
+    credentials: {
+        apiKey: string;
+    };
+};
+export { SpeechResult, StreamSpeech, SttConfig, GoogleSttConfig, DeepgramSttConfig, DeepgramModel };

package/dist/voice/stt/types.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepgramModel = void 0;
+var DeepgramModel;
+(function (DeepgramModel) {
+    DeepgramModel["NOVA_2"] = "nova-2";
+    DeepgramModel["NOVA_2_PHONECALL"] = "nova-2-phonecall";
+    DeepgramModel["NOVA_2_CONVERSATIONALAI"] = "nova-2-conversationalai";
+})(DeepgramModel || (exports.DeepgramModel = DeepgramModel = {}));

package/dist/voice/tts/Deepgram.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod";
+import { AbstractTextToSpeech } from "./AbstractTextToSpeech";
+import { SynthOptions, TtsConfig } from "./types";
+declare const DeepgramClient: any;
+declare const ENGINE_NAME = "tts.deepgram";
+type DeepgramTtsConfig = TtsConfig & {
+    [key: string]: Record<string, string>;
+    credentials: {
+        apiKey: string;
+    };
+};
+declare class Deepgram extends AbstractTextToSpeech<typeof ENGINE_NAME> {
+    client: typeof DeepgramClient;
+    engineConfig: DeepgramTtsConfig;
+    readonly engineName = "tts.deepgram";
+    protected readonly OUTPUT_FORMAT = "sln16";
+    protected readonly CACHING_FIELDS: string[];
+    protected readonly AUDIO_ENCODING: "linear16";
+    protected readonly SAMPLE_RATE_HERTZ = 16000;
+    constructor(config: DeepgramTtsConfig);
+    synthesize(text: string, options: SynthOptions): Promise<string>;
+    static getConfigValidationSchema(): z.Schema;
+    static getCredentialsValidationSchema(): z.Schema;
+}
+export { Deepgram, ENGINE_NAME };