@fonoster/apiserver 0.5.5 → 0.6.1

package/dist/voice/handlers/dial/recordChannel.js

@@ -0,0 +1,45 @@
+"use strict";
+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.recordChannel = recordChannel;
+/*
+ * 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 common_1 = require("@fonoster/common");
+function recordChannel(ari, direction, sessionRef) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const channel = yield ari.channels.snoopChannel({
+            app: common_1.STASIS_APP_NAME,
+            channelId: sessionRef,
+            spy: direction
+        });
+        return ari.channels.record({
+            channelId: channel.id,
+            format: common_1.RecordFormat.WAV,
+            name: `${sessionRef}_${direction}`
+        });
+    });
+}

package/dist/voice/handlers/gather/Gather.d.ts

@@ -0,0 +1,3 @@
+import { VoiceClient } from "../../types";
+declare function gatherHandler(voiceClient: VoiceClient): (request: import("@fonoster/common").VerbRequest) => Promise<void>;
+export { gatherHandler };

package/dist/voice/handlers/gather/Gather.js

@@ -0,0 +1,72 @@
+"use strict";
+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.gatherHandler = gatherHandler;
+/*
+ * 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 common_1 = require("@fonoster/common");
+const zod_1 = require("zod");
+const getTimeoutPromise_1 = require("./getTimeoutPromise");
+const withErrorHandling_1 = require("../withErrorHandling");
+const isDtmf = (digit) => /^[0-9*#]+$/.test(digit);
+const gatherRequestSchema = zod_1.z.object({
+    maxDigits: zod_1.z.number().optional().nullable(),
+    // TODO: Ensure it is a dtmf character
+    finishOnKey: zod_1.z.string().max(1).optional().nullable()
+});
+function gatherHandler(voiceClient) {
+    return (0, withErrorHandling_1.withErrorHandling)((request) => __awaiter(this, void 0, void 0, function* () {
+        const { sessionRef, source, timeout, finishOnKey, maxDigits } = request;
+        // Error handled by withErrorHandling
+        gatherRequestSchema.parse(request);
+        const { timeoutPromise, effectiveTimeout } = (0, getTimeoutPromise_1.getTimeoutPromise)(timeout);
+        const effectiveSource = source || common_1.GatherSource.SPEECH_AND_DTMF;
+        const promises = [timeoutPromise];
+        if (effectiveSource.includes(common_1.GatherSource.SPEECH)) {
+            promises.push(voiceClient.transcribe().then((result) => result.speech));
+        }
+        if (effectiveSource.includes(common_1.GatherSource.DTMF)) {
+            promises.push(voiceClient
+                .waitForDtmf({
+                sessionRef,
+                finishOnKey,
+                maxDigits,
+                timeout: effectiveTimeout,
+                onDigitReceived: timeoutPromise.cancelGlobalTimer
+            })
+                .then(({ digits }) => digits));
+        }
+        const result = yield Promise.race(promises);
+        voiceClient.sendResponse({
+            gatherResponse: {
+                sessionRef,
+                speech: isDtmf(result) ? null : result,
+                digits: isDtmf(result) ? result : null
+            }
+        });
+    }));
+}

package/dist/voice/handlers/gather/getTimeoutPromise.d.ts

@@ -0,0 +1,8 @@
+interface PromiseWithResetTimer<T> extends Promise<T> {
+    cancelGlobalTimer?: () => void;
+}
+declare function getTimeoutPromise(timeout: number): {
+    timeoutPromise: PromiseWithResetTimer<string>;
+    effectiveTimeout: number;
+};
+export { getTimeoutPromise };

package/dist/voice/handlers/gather/getTimeoutPromise.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeoutPromise = getTimeoutPromise;
+function getTimeoutPromise(timeout) {
+    const effectiveTimeout = timeout || 5000;
+    let timeoutId = null;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => {
+            resolve("");
+        }, effectiveTimeout);
+    });
+    timeoutPromise.cancelGlobalTimer = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    };
+    return { timeoutPromise, effectiveTimeout };
+}

package/dist/voice/handlers/withErrorHandling.d.ts

@@ -0,0 +1,4 @@
+import { VerbRequest } from "@fonoster/common";
+type VerbHandler = (request: VerbRequest) => Promise<void>;
+declare function withErrorHandling(fn: VerbHandler): (request: VerbRequest) => Promise<void>;
+export { withErrorHandling };

package/dist/voice/handlers/withErrorHandling.js

@@ -0,0 +1,35 @@
+"use strict";
+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.withErrorHandling = withErrorHandling;
+const logger_1 = require("@fonoster/logger");
+const zod_1 = require("zod");
+const zod_validation_error_1 = require("zod-validation-error");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+// TODO: Send error to the client and to the log system
+function withErrorHandling(fn) {
+    return (request) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield fn(request);
+        }
+        catch (err) {
+            if (err instanceof zod_1.z.ZodError) {
+                const validationError = (0, zod_validation_error_1.fromError)(err);
+                logger.error("Validation error:", {
+                    message: validationError.toString()
+                });
+            }
+            else if (err.message !== "Channel not found") {
+                throw err;
+            }
+        }
+    });
+}

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

@@ -0,0 +1,4 @@
+declare class ApplicationNotFoundError extends Error {
+    constructor(appRef: string);
+}
+export { ApplicationNotFoundError };

package/dist/voice/integrations/ApplicationNotFoundError.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationNotFoundError = void 0;
+/*
+ * 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.
+ */
+class ApplicationNotFoundError extends Error {
+    constructor(appRef) {
+        super(`Application not found: ${appRef}`);
+        this.name = this.constructor.name;
+    }
+}
+exports.ApplicationNotFoundError = ApplicationNotFoundError;

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

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

package/dist/voice/integrations/findIntegrationsCredentials.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findIntegrationsCredentials = findIntegrationsCredentials;
+function findIntegrationsCredentials(integrations, engine) {
+    return integrations.find((i) => i.productRef === engine);
+}

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

@@ -0,0 +1,7 @@
+import { Application, VoiceLanguage } from "@fonoster/common";
+import { IntegrationConfig } from "./types";
+declare function getSttConfig(integrations: IntegrationConfig[], app: Application): {
+    credentials: IntegrationConfig;
+    languageCode: VoiceLanguage;
+};
+export { getSttConfig };

package/dist/voice/integrations/getSttConfig.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSttConfig = getSttConfig;
+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 });
+}

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

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

package/dist/voice/integrations/getTtsConfig.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTtsConfig = getTtsConfig;
+const findIntegrationsCredentials_1 = require("./findIntegrationsCredentials");
+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 });
+}

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

@@ -0,0 +1 @@
+export * from "./makeCreateContainer";

package/dist/voice/integrations/index.js

@@ -0,0 +1,35 @@
+"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("./makeCreateContainer"), exports);

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

@@ -0,0 +1,4 @@
+import { IntegrationsContainer } from "./types";
+import { Prisma } from "../../core/db";
+declare function makeCreateContainer(prisma: Prisma, pathToIntegrations: string): (appRef: string) => Promise<IntegrationsContainer>;
+export { makeCreateContainer };

package/dist/voice/integrations/makeCreateContainer.js

@@ -0,0 +1,88 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCreateContainer = makeCreateContainer;
+/*
+ * 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 fs_1 = __importDefault(require("fs"));
+const logger_1 = require("@fonoster/logger");
+const zod_1 = require("zod");
+const zod_validation_error_1 = require("zod-validation-error");
+const ApplicationNotFoundError_1 = require("./ApplicationNotFoundError");
+const getSttConfig_1 = require("./getSttConfig");
+const getTtsConfig_1 = require("./getTtsConfig");
+const SpeechToTextFactory_1 = require("../stt/SpeechToTextFactory");
+const TextToSpeechFactory_1 = require("../tts/TextToSpeechFactory");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+const integrationsConfigSchema = zod_1.z.array(zod_1.z.object({
+    name: zod_1.z.string(),
+    productRef: zod_1.z.string(),
+    type: zod_1.z.enum(["tts", "stt"]),
+    credentials: zod_1.z.record(zod_1.z.unknown())
+}));
+function makeCreateContainer(prisma, pathToIntegrations) {
+    logger.verbose("loading integrations config", { pathToIntegrations });
+    const integrationsFile = fs_1.default.readFileSync(pathToIntegrations, "utf8");
+    const integrations = JSON.parse(integrationsFile);
+    try {
+        integrationsConfigSchema.parse(integrations);
+    }
+    catch (e) {
+        // fatal error
+        const message = (0, zod_validation_error_1.fromError)(e);
+        logger.error("integrations config is invalid", { message });
+        process.exit(1);
+    }
+    return (appRef) => __awaiter(this, void 0, void 0, function* () {
+        logger.verbose("creating integrations container", { appRef });
+        const app = yield prisma.application.findUnique({
+            where: { ref: appRef },
+            include: {
+                textToSpeech: true,
+                speechToText: true,
+                intelligence: true
+            }
+        });
+        if (!app) {
+            throw new ApplicationNotFoundError_1.ApplicationNotFoundError(appRef);
+        }
+        const ttsConfig = (0, getTtsConfig_1.getTtsConfig)(integrations, app);
+        const sttConfig = (0, getSttConfig_1.getSttConfig)(integrations, app);
+        const tts = TextToSpeechFactory_1.TextToSpeechFactory.getEngine(app.textToSpeech.productRef, ttsConfig);
+        const stt = SpeechToTextFactory_1.SpeechToTextFactory.getEngine(app.speechToText.productRef, sttConfig);
+        return {
+            ref: appRef,
+            accessKeyId: app.accessKeyId,
+            appEndpoint: app.appEndpoint,
+            tts,
+            stt
+        };
+    });
+}

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

@@ -0,0 +1,15 @@
+import { AbstractSpeechToText } from "../stt/AbstractSpeechToText";
+import { AbstractTextToSpeech } from "../tts/AbstractTextToSpeech";
+type IntegrationConfig = {
+    productRef: string;
+    credentials: Record<string, unknown>;
+};
+type IntegrationsContainer = {
+    ref: string;
+    accessKeyId: string;
+    appEndpoint: string;
+    tts: AbstractTextToSpeech<unknown>;
+    stt: AbstractSpeechToText<unknown>;
+};
+type CreateContainer = (appRef: string) => Promise<IntegrationsContainer>;
+export { IntegrationConfig, IntegrationsContainer, CreateContainer };

package/dist/voice/integrations/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/voice/makeCreateVoiceClient.d.ts

@@ -0,0 +1,9 @@
+import { Channel, Client, StasisStart } from "ari-client";
+import { CreateContainer } from "./integrations/types";
+import { VoiceClient } from "./types";
+declare function makeCreateVoiceClient(createContainer: CreateContainer): (params: {
+    ari: Client;
+    event: StasisStart;
+    channel: Channel;
+}) => Promise<VoiceClient>;
+export { makeCreateVoiceClient };

package/dist/voice/makeCreateVoiceClient.js

@@ -0,0 +1,77 @@
+"use strict";
+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.makeCreateVoiceClient = makeCreateVoiceClient;
+/*
+ * 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 identity_1 = require("@fonoster/identity");
+const logger_1 = require("@fonoster/logger");
+const makeGetChannelVar_1 = require("./makeGetChannelVar");
+const types_1 = require("./types");
+const VoiceClientImpl_1 = require("./VoiceClientImpl");
+const identityConfig_1 = require("../core/identityConfig");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+const createToken = (0, identity_1.createCallAccessToken)(identityConfig_1.identityConfig);
+// Note: By the time the call arrives here the owner of the app MUST be authenticated
+function makeCreateVoiceClient(createContainer) {
+    return (params) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const { ari, event, channel } = params;
+        const { id: sessionRef, caller } = event.channel;
+        const { name: callerName, number: callerNumber } = caller;
+        const getChannelVar = (0, makeGetChannelVar_1.makeGetChannelVar)(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 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 config = {
+            appRef,
+            sessionRef,
+            accessKeyId,
+            appEndpoint,
+            callerName,
+            callerNumber,
+            ingressNumber,
+            sessionToken,
+            metadata: metadataStr ? JSON.parse(metadataStr) : {}
+        };
+        logger.verbose("creating voice client with config: ", {
+            appRef,
+            callerNumber,
+            ingressNumber
+        });
+        return new VoiceClientImpl_1.VoiceClientImpl({ ari, config, tts, stt });
+    });
+}

package/dist/voice/makeGetChannelVar.d.ts

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

package/dist/voice/makeGetChannelVar.js

@@ -0,0 +1,25 @@
+"use strict";
+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.makeGetChannelVar = makeGetChannelVar;
+const ChannelVarNotFoundError_1 = require("./ChannelVarNotFoundError");
+function makeGetChannelVar(channel) {
+    return (variable) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield channel.getChannelVar({
+                variable
+            });
+        }
+        catch (e) {
+            throw new ChannelVarNotFoundError_1.ChannelVarNotFoundError(variable);
+        }
+    });
+}

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

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

package/dist/voice/stt/AbstractSpeechToText.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSpeechToText = void 0;
+const MethodNotImplementedError_1 = require("../MethodNotImplementedError");
+class AbstractSpeechToText {
+    constructor(config) {
+        this.config = config;
+    }
+    getName() {
+        return this.engineName;
+    }
+    static getConfigValidationSchema() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    static getCredentialsValidationSchema() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+}
+exports.AbstractSpeechToText = AbstractSpeechToText;

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

@@ -0,0 +1,19 @@
+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";
+declare const ENGINE_NAME = "stt.google";
+declare class Google extends AbstractSpeechToText<typeof ENGINE_NAME> {
+    client: SpeechClient;
+    config: GoogleSttConfig;
+    readonly engineName = "stt.google";
+    protected readonly AUDIO_ENCODING = "LINEAR16";
+    protected readonly SAMPLE_RATE_HERTZ = 16000;
+    constructor(config: GoogleSttConfig);
+    streamTranscribe(_: Stream): StreamSpeechResult;
+    transcribe(stream: Stream): Promise<SpeechResult>;
+    static getConfigValidationSchema(): z.Schema;
+    static getCredentialsValidationSchema(): z.Schema;
+}
+export { Google, ENGINE_NAME };