@corti/sdk 0.0.0-alpha.10

package/dist/esm/custom/CortiAuth.mjs

@@ -0,0 +1,145 @@
+/**
+ * This file is implementation of the Auth client that can be used in 2 scenarios:
+ * 1. Under the hood by the package when Client credentials are used
+ * 2. Directly imported by the user to implement Authorization code flow
+ *
+ * Locally based on the auto-generated Auth client (src/api/resources/auth/client/Client.ts), but with some changes:
+ * 1. Token request sends proper `application/x-www-form-urlencoded` content type instead of `application/json`
+ * 2. Token request accepts additional parameters to support Authorization code flow
+ * 3. Additional methods to support Authorization code flow
+ *
+ * All methods are re-implemented, but class still extends the auto-generated one to make sure that we keep the same interface
+ *  and to maybe remove some of the re-implementations in the future when `x-www-form-urlencoded` is supported
+ */
+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());
+    });
+};
+import { Auth as FernAuth } from "../api/resources/auth/client/Client.mjs";
+import * as core from "../core/index.mjs";
+import { mergeHeaders, mergeOnlyDefinedHeaders } from "../core/headers.mjs";
+import urlJoin from "url-join";
+import * as errors from "../errors/index.mjs";
+import * as environments from "../environments.mjs";
+export class Auth extends FernAuth {
+    /**
+     * Patch: called custom implementation this.__getToken_custom instead of this.__getToken
+     */
+    getToken(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getToken_custom(request, requestOptions));
+    }
+    /**
+     * Patch: added method to get Authorization URL for Authorization code flow
+     */
+    authorizeURL(_a, options_1) {
+        return __awaiter(this, arguments, void 0, function* ({ client_id, redirect_uri, }, options) {
+            var _b, _c;
+            const authUrl = new URL(urlJoin((_b = (yield core.Supplier.get(this._options.baseUrl))) !== null && _b !== void 0 ? _b : ((_c = (yield core.Supplier.get(this._options.environment))) !== null && _c !== void 0 ? _c : environments.CortiEnvironment.BetaEu)
+                .login, yield core.Supplier.get(this._options.tenantName), "protocol/openid-connect/auth"));
+            authUrl.searchParams.set('response_type', 'code');
+            authUrl.searchParams.set('scope', 'openid profile');
+            if (client_id !== undefined) {
+                authUrl.searchParams.set('client_id', client_id);
+            }
+            if (redirect_uri !== undefined) {
+                authUrl.searchParams.set('redirect_uri', redirect_uri);
+            }
+            const authUrlString = authUrl.toString();
+            if (typeof window !== "undefined" && !(options === null || options === void 0 ? void 0 : options.skipRedirect)) {
+                window.location.href = authUrlString;
+                return authUrlString;
+            }
+            return authUrlString;
+        });
+    }
+    /**
+     * Patch: calls __getToken_custom with additional fields to support Authorization code flow
+     */
+    getCodeFlowToken(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getToken_custom(Object.assign(Object.assign({}, request), { grant_type: "authorization_code" }), requestOptions));
+    }
+    /**
+     * Patch: copy of this.__getToken with patches
+     */
+    __getToken_custom(
+    /**
+     * Patch: added additional fields to request to support Authorization code flow
+     */
+    request, requestOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const _response = yield core.fetcher({
+                url: urlJoin((_a = (yield core.Supplier.get(this._options.baseUrl))) !== null && _a !== void 0 ? _a : (yield core.Supplier.get(this._options.environment)).login, 
+                /**
+                 * Patch: use tenantName as path parameter
+                 *  (consider to be generated from the spec in the future)
+                 */
+                yield core.Supplier.get(this._options.tenantName), "protocol/openid-connect/token"),
+                method: "POST",
+                headers: mergeHeaders((_b = this._options) === null || _b === void 0 ? void 0 : _b.headers, mergeOnlyDefinedHeaders({
+                    /**
+                     * Patch: Removed `Authorization` header, as it is not needed for getting the token
+                     */
+                    "Tenant-Name": requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.tenantName,
+                }), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers),
+                contentType: "application/x-www-form-urlencoded",
+                /**
+                 * Patch: removed `requestType: "json"`, made body a URLSearchParams object
+                 */
+                body: new URLSearchParams(Object.assign(Object.assign(Object.assign(Object.assign({}, request), { scope: "openid", 
+                    /**
+                     * Patch: `grant_type` uses values from request or defaults to "client_credentials"
+                     */
+                    grant_type: request.grant_type || "client_credentials" }), (request.grant_type === "authorization_code"
+                    ? {
+                        code: request.code,
+                        redirect_uri: request.redirect_uri
+                    }
+                    : {})), (request.grant_type === "refresh_token"
+                    ? {
+                        refresh_token: request.refresh_token,
+                    }
+                    : {}))),
+                timeoutMs: (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
+                maxRetries: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.maxRetries,
+                abortSignal: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.abortSignal,
+            });
+            if (_response.ok) {
+                return { data: _response.body, rawResponse: _response.rawResponse };
+            }
+            if (_response.error.reason === "status-code") {
+                throw new errors.CortiError({
+                    statusCode: _response.error.statusCode,
+                    body: _response.error.body,
+                    rawResponse: _response.rawResponse,
+                });
+            }
+            switch (_response.error.reason) {
+                case "non-json":
+                    throw new errors.CortiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.rawBody,
+                        rawResponse: _response.rawResponse,
+                    });
+                case "timeout":
+                    throw new errors.CortiTimeoutError("Timeout exceeded when calling POST /protocol/openid-connect/token.");
+                case "unknown":
+                    throw new errors.CortiError({
+                        message: _response.error.errorMessage,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        });
+    }
+    /**
+     * Patch: calls __getToken_custom with additional fields to support Refresh token flow
+     */
+    refreshToken(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getToken_custom(Object.assign(Object.assign({}, request), { grant_type: "refresh_token" }), requestOptions));
+    }
+}

package/dist/esm/custom/CortiClient.d.mts

@@ -0,0 +1,113 @@
+/**
+ * This file is the custom implementation of the main CortiClient class (src/Client.ts)
+ *
+ * It's (almost) handwritten, and it replaces the auto-generated version, and here is why:
+ *
+ * 1. The auto-generated version uses direct client imports -> we can not always easily replace them without a patch in Main client
+ * 2. The auto-generated version produces TypeScript error when initializes authClient in `_oauthTokenProvider`
+ * 3. `_oauthTokenProvider` is a private field in the auto-generated version,
+ *   so we cannot easily rewrite it in the custom implementation. We can use another field for OAuthProvider,
+ *   but then we need to rewrite all the methods anyway => it will be easier to forget,
+ *   since it would exist in the class, but not properly implemented
+ *
+ * => Must be manually synced with src/Client.ts (which is auto-generated).
+ *
+ * All the patches marked with `// Patch: ...` comments.
+ */
+import * as environments from "../environments.mjs";
+import * as core from "../core/index.mjs";
+import { Interactions } from "../api/resources/interactions/client/Client.mjs";
+import { Recordings } from "../api/resources/recordings/client/Client.mjs";
+import { Transcripts } from "../api/resources/transcripts/client/Client.mjs";
+import { Facts } from "../api/resources/facts/client/Client.mjs";
+import { Documents } from "../api/resources/documents/client/Client.mjs";
+import { Templates } from "../api/resources/templates/client/Client.mjs";
+/**
+ * Patch: changed import to custom Stream and Transcribe implementations
+ */
+import { Stream } from "./CustomStream.mjs";
+import { Transcribe } from "./CustomTranscribe.mjs";
+/**
+ * Patch: added custom RefreshBearerProvider
+ */
+import { BearerOptions } from "./RefreshBearerProvider.mjs";
+export declare namespace CortiClient {
+    /**
+     * Patch: added new public interface for `Options` (+ `ClientCredentials` interface)
+     */
+    interface ClientCredentials {
+        clientId: core.Supplier<string>;
+        clientSecret: core.Supplier<string>;
+    }
+    interface Options {
+        environment: core.Supplier<environments.CortiEnvironment | environments.CortiEnvironmentUrls>;
+        /** Override the Tenant-Name header */
+        tenantName: core.Supplier<string>;
+        /** Additional headers to include in requests. */
+        headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
+        auth: ClientCredentials | BearerOptions;
+    }
+    /**
+     * Patch:
+     *  - renamed `Options` to `InternalOptions`
+     *  - added `token` field to support BearerProvider
+     *  - made clientId and clientSecret optional
+     */
+    interface InternalOptions {
+        environment: core.Supplier<environments.CortiEnvironment | environments.CortiEnvironmentUrls>;
+        /** Specify a custom URL to connect the client to. */
+        baseUrl?: core.Supplier<string>;
+        clientId?: core.Supplier<string>;
+        clientSecret?: core.Supplier<string>;
+        token?: core.Supplier<string>;
+        /** Override the Tenant-Name header */
+        tenantName: core.Supplier<string>;
+        /** Additional headers to include in requests. */
+        headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
+    }
+    interface RequestOptions {
+        /** The maximum time to wait for a response in seconds. */
+        timeoutInSeconds?: number;
+        /** The number of times to retry the request. Defaults to 2. */
+        maxRetries?: number;
+        /** A hook to abort the request. */
+        abortSignal?: AbortSignal;
+        /** Override the Tenant-Name header */
+        tenantName?: string;
+        /** Additional headers to include in the request. */
+        headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
+    }
+}
+export declare class CortiClient {
+    /**
+     * Patch: this._options is now of type `CortiClient.InternalOptions` (which matches generated implementation)
+     */
+    protected readonly _options: CortiClient.InternalOptions;
+    /**
+     * Patch: extended `_oauthTokenProvider` to support both `RefreshBearerProvider` and `OAuthTokenProvider` options
+     */
+    private readonly _oauthTokenProvider;
+    protected _interactions: Interactions | undefined;
+    protected _recordings: Recordings | undefined;
+    protected _transcripts: Transcripts | undefined;
+    protected _facts: Facts | undefined;
+    protected _templates: Templates | undefined;
+    protected _documents: Documents | undefined;
+    /**
+     * Patch: removed `auth` field
+     * `_oauthTokenProvider` uses Auth module directly to get the token,
+     *   and our client also don't need to use it within the main client.
+     *   For other cases they can use `CortiAuth` module directly.
+     */
+    protected _stream: Stream | undefined;
+    protected _transcribe: Transcribe | undefined;
+    constructor(_options: CortiClient.Options);
+    get interactions(): Interactions;
+    get recordings(): Recordings;
+    get transcripts(): Transcripts;
+    get facts(): Facts;
+    get documents(): Documents;
+    get templates(): Templates;
+    get stream(): Stream;
+    get transcribe(): Transcribe;
+}

package/dist/esm/custom/CortiClient.mjs

@@ -0,0 +1,111 @@
+/**
+ * This file is the custom implementation of the main CortiClient class (src/Client.ts)
+ *
+ * It's (almost) handwritten, and it replaces the auto-generated version, and here is why:
+ *
+ * 1. The auto-generated version uses direct client imports -> we can not always easily replace them without a patch in Main client
+ * 2. The auto-generated version produces TypeScript error when initializes authClient in `_oauthTokenProvider`
+ * 3. `_oauthTokenProvider` is a private field in the auto-generated version,
+ *   so we cannot easily rewrite it in the custom implementation. We can use another field for OAuthProvider,
+ *   but then we need to rewrite all the methods anyway => it will be easier to forget,
+ *   since it would exist in the class, but not properly implemented
+ *
+ * => Must be manually synced with src/Client.ts (which is auto-generated).
+ *
+ * All the patches marked with `// Patch: ...` comments.
+ */
+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());
+    });
+};
+import * as core from "../core/index.mjs";
+/**
+ * Patch: changed import to custom Auth implementation
+ */
+import { Auth } from "./CortiAuth.mjs";
+import { mergeHeaders } from "../core/headers.mjs";
+import { Interactions } from "../api/resources/interactions/client/Client.mjs";
+import { Recordings } from "../api/resources/recordings/client/Client.mjs";
+import { Transcripts } from "../api/resources/transcripts/client/Client.mjs";
+import { Facts } from "../api/resources/facts/client/Client.mjs";
+import { Documents } from "../api/resources/documents/client/Client.mjs";
+import { Templates } from "../api/resources/templates/client/Client.mjs";
+/**
+ * Patch: changed import to custom Stream and Transcribe implementations
+ */
+import { Stream } from "./CustomStream.mjs";
+import { Transcribe } from "./CustomTranscribe.mjs";
+/**
+ * Patch: added custom RefreshBearerProvider
+ */
+import { RefreshBearerProvider } from "./RefreshBearerProvider.mjs";
+/**
+ * Patch: added SDK_VERSION import
+ */
+import { SDK_VERSION } from '../version.mjs';
+export class CortiClient {
+    constructor(_options) {
+        this._options = Object.assign(Object.assign({}, _options), { headers: mergeHeaders({
+                "Tenant-Name": _options === null || _options === void 0 ? void 0 : _options.tenantName,
+                "X-Fern-Language": "JavaScript",
+                "X-Fern-SDK-Name": "@corti/sdk",
+                /**
+                 * Patch: replaced hardcoded SDK version with imported one
+                 */
+                "X-Fern-SDK-Version": SDK_VERSION,
+                "User-Agent": `@corti/sdk/${SDK_VERSION}`,
+                "X-Fern-Runtime": core.RUNTIME.type,
+                "X-Fern-Runtime-Version": core.RUNTIME.version,
+            }, _options === null || _options === void 0 ? void 0 : _options.headers), clientId: "clientId" in _options.auth ? _options.auth.clientId : undefined, clientSecret: "clientSecret" in _options.auth ? _options.auth.clientSecret : undefined, token: "access_token" in _options.auth ? _options.auth.access_token : undefined });
+        /**
+         * Patch: if `accessToken` is provided, use BearerProvider, otherwise use OAuthTokenProvider
+         */
+        this._oauthTokenProvider = "access_token" in _options.auth ?
+            new RefreshBearerProvider(_options.auth) :
+            new core.OAuthTokenProvider({
+                clientId: _options.auth.clientId,
+                clientSecret: _options.auth.clientSecret,
+                /**
+                 * Patch: provide whole `options` object to the Auth client, since it depends on both tenantName and environment
+                 */
+                authClient: new Auth(this._options),
+            });
+    }
+    get interactions() {
+        var _a;
+        return ((_a = this._interactions) !== null && _a !== void 0 ? _a : (this._interactions = new Interactions(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
+    }
+    get recordings() {
+        var _a;
+        return ((_a = this._recordings) !== null && _a !== void 0 ? _a : (this._recordings = new Recordings(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
+    }
+    get transcripts() {
+        var _a;
+        return ((_a = this._transcripts) !== null && _a !== void 0 ? _a : (this._transcripts = new Transcripts(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
+    }
+    get facts() {
+        var _a;
+        return ((_a = this._facts) !== null && _a !== void 0 ? _a : (this._facts = new Facts(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
+    }
+    get documents() {
+        var _a;
+        return ((_a = this._documents) !== null && _a !== void 0 ? _a : (this._documents = new Documents(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
+    }
+    get templates() {
+        var _a;
+        return ((_a = this._templates) !== null && _a !== void 0 ? _a : (this._templates = new Templates(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
+    }
+    get stream() {
+        var _a;
+        return ((_a = this._stream) !== null && _a !== void 0 ? _a : (this._stream = new Stream(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
+    }
+    get transcribe() {
+        var _a;
+        return ((_a = this._transcribe) !== null && _a !== void 0 ? _a : (this._transcribe = new Transcribe(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
+    }
+}

package/dist/esm/custom/CustomStream.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Patch: use custom Stream implementation to support passing _options parameters to connection function
+ */
+import { Stream as FernStream } from "../api/resources/stream/client/Client.mjs";
+/**
+ * Patch: changed import to custom StreamSocket implementation
+ */
+import { StreamSocket } from "./CustomStreamSocket.mjs";
+export declare class Stream extends FernStream {
+    connect(args: Omit<FernStream.ConnectArgs, 'token' | 'tenant-name'>): Promise<StreamSocket>;
+    /**
+     * Patch: temporary fix of WS URL generation, while it doesn't work from Ferns side
+     */
+    private __connect_patch;
+}

package/dist/esm/custom/CustomStream.mjs

@@ -0,0 +1,45 @@
+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());
+    });
+};
+/**
+ * Patch: use custom Stream implementation to support passing _options parameters to connection function
+ */
+import { Stream as FernStream } from "../api/resources/stream/client/Client.mjs";
+import * as core from "../core/index.mjs";
+/**
+ * Patch: changed import to custom StreamSocket implementation
+ */
+import { StreamSocket } from "./CustomStreamSocket.mjs";
+import * as qs from "qs";
+export class Stream extends FernStream {
+    connect(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.__connect_patch(Object.assign(Object.assign({}, args), { token: yield this._getAuthorizationHeader(), "tenant-name": yield core.Supplier.get(this._options.tenantName) }));
+        });
+    }
+    /**
+     * Patch: temporary fix of WS URL generation, while it doesn't work from Ferns side
+     */
+    __connect_patch(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const queryParams = {};
+            if (args["tenant-name"] != null) {
+                queryParams["tenant-name"] = args["tenant-name"];
+            }
+            if (args["token"] != null) {
+                queryParams["token"] = args["token"];
+            }
+            let websocketHeaders = {};
+            websocketHeaders = Object.assign(Object.assign({}, websocketHeaders), args["headers"]);
+            const socket = new core.ReconnectingWebSocket(`${(_a = (yield core.Supplier.get(this._options["baseUrl"]))) !== null && _a !== void 0 ? _a : (yield core.Supplier.get(this._options["environment"])).wss}/audio-bridge/v2/interactions/${encodeURIComponent(args["id"])}/streams?${qs.stringify(queryParams, { arrayFormat: "repeat" })}`, [], { debug: (_b = args["debug"]) !== null && _b !== void 0 ? _b : false, maxRetries: (_c = args["reconnectAttempts"]) !== null && _c !== void 0 ? _c : 30 }, websocketHeaders);
+            return new StreamSocket({ socket });
+        });
+    }
+}

package/dist/esm/custom/CustomStreamSocket.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Patch: file patches disability of auto-generating binary data methods for sending data to the socket
+ */
+import { StreamSocket as FernStreamSocket } from '../api/resources/stream/client/Socket.mjs';
+export declare class StreamSocket extends FernStreamSocket {
+    sendAudio(message: ArrayBuffer | string): void;
+    /**
+     * Patch: have to repeat this method, because it is private in the base class
+     */
+    private __assertSocketIsOpen;
+}

package/dist/esm/custom/CustomStreamSocket.mjs

@@ -0,0 +1,25 @@
+/**
+ * Patch: file patches disability of auto-generating binary data methods for sending data to the socket
+ */
+import { StreamSocket as FernStreamSocket } from '../api/resources/stream/client/Socket.mjs';
+import * as core from "../core/index.mjs";
+export class StreamSocket extends FernStreamSocket {
+    sendAudio(message) {
+        if (typeof message === 'string') {
+            return super.sendAudio(message);
+        }
+        this.__assertSocketIsOpen();
+        this.socket.send(message);
+    }
+    /**
+     * Patch: have to repeat this method, because it is private in the base class
+     */
+    __assertSocketIsOpen() {
+        if (!this.socket) {
+            throw new Error("Socket is not connected.");
+        }
+        if (this.socket.readyState !== core.ReconnectingWebSocket.OPEN) {
+            throw new Error("Socket is not open.");
+        }
+    }
+}

package/dist/esm/custom/CustomTranscribe.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Patch: use custom Transcribe implementation to support passing _options parameters to connection function
+ */
+import { Transcribe as FernTranscribe } from "../api/resources/transcribe/client/Client.mjs";
+/**
+ * Patch: changed import to custom TranscribeSocket implementation
+ */
+import { TranscribeSocket } from "./CustomTranscribeSocket.mjs";
+export declare class Transcribe extends FernTranscribe {
+    connect(args?: Omit<FernTranscribe.ConnectArgs, 'token' | 'tenant-name'>): Promise<TranscribeSocket>;
+    /**
+     * Patch: temporary fix of WS generation, while binary type isn't supported from Ferns side
+     */
+    private __connect_patch;
+}

package/dist/esm/custom/CustomTranscribe.mjs

@@ -0,0 +1,45 @@
+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());
+    });
+};
+/**
+ * Patch: use custom Transcribe implementation to support passing _options parameters to connection function
+ */
+import { Transcribe as FernTranscribe } from "../api/resources/transcribe/client/Client.mjs";
+import * as core from "../core/index.mjs";
+/**
+ * Patch: changed import to custom TranscribeSocket implementation
+ */
+import { TranscribeSocket } from "./CustomTranscribeSocket.mjs";
+import * as qs from "qs";
+export class Transcribe extends FernTranscribe {
+    connect() {
+        return __awaiter(this, arguments, void 0, function* (args = {}) {
+            return this.__connect_patch(Object.assign(Object.assign({}, args), { token: yield this._getAuthorizationHeader(), "tenant-name": yield core.Supplier.get(this._options.tenantName) }));
+        });
+    }
+    /**
+     * Patch: temporary fix of WS generation, while binary type isn't supported from Ferns side
+     */
+    __connect_patch(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const queryParams = {};
+            if (args["tenant-name"] != null) {
+                queryParams["tenant-name"] = args["tenant-name"];
+            }
+            if (args["token"] != null) {
+                queryParams["token"] = args["token"];
+            }
+            let websocketHeaders = {};
+            websocketHeaders = Object.assign(Object.assign({}, websocketHeaders), args["headers"]);
+            const socket = new core.ReconnectingWebSocket(`${(_a = (yield core.Supplier.get(this._options["baseUrl"]))) !== null && _a !== void 0 ? _a : (yield core.Supplier.get(this._options["environment"])).wss}/audio-bridge/v2/transcribe?${qs.stringify(queryParams, { arrayFormat: "repeat" })}`, [], { debug: (_b = args["debug"]) !== null && _b !== void 0 ? _b : false, maxRetries: (_c = args["reconnectAttempts"]) !== null && _c !== void 0 ? _c : 30 }, websocketHeaders);
+            return new TranscribeSocket({ socket });
+        });
+    }
+}

package/dist/esm/custom/CustomTranscribeSocket.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Patch: file patches disability of auto-generating binary data methods for sending data to the socket
+ */
+import { TranscribeSocket as FernTranscribeSocket } from '../api/resources/transcribe/client/Socket.mjs';
+export declare class TranscribeSocket extends FernTranscribeSocket {
+    sendAudio(message: ArrayBuffer | string): void;
+    /**
+     * Patch: have to repeat this method, because it is private in the base class
+     */
+    private __assertSocketIsOpen;
+}

package/dist/esm/custom/CustomTranscribeSocket.mjs

@@ -0,0 +1,25 @@
+/**
+ * Patch: file patches disability of auto-generating binary data methods for sending data to the socket
+ */
+import { TranscribeSocket as FernTranscribeSocket } from '../api/resources/transcribe/client/Socket.mjs';
+import * as core from "../core/index.mjs";
+export class TranscribeSocket extends FernTranscribeSocket {
+    sendAudio(message) {
+        if (typeof message === 'string') {
+            return super.sendAudio(message);
+        }
+        this.__assertSocketIsOpen();
+        this.socket.send(message);
+    }
+    /**
+     * Patch: have to repeat this method, because it is private in the base class
+     */
+    __assertSocketIsOpen() {
+        if (!this.socket) {
+            throw new Error("Socket is not connected.");
+        }
+        if (this.socket.readyState !== core.ReconnectingWebSocket.OPEN) {
+            throw new Error("Socket is not open.");
+        }
+    }
+}

package/dist/esm/custom/RefreshBearerProvider.d.mts

@@ -0,0 +1,23 @@
+/**
+ * RefreshBearerProvider used as a replacement of OAuthTokenProvider, in case when accessToken from outside of library was used instead of Client credentials.
+ */
+import * as core from "../core/index.mjs";
+import * as api from "../api/index.mjs";
+type RefreshAccessTokenFunction = (refreshToken?: string) => Promise<api.GetTokenResponse> | api.GetTokenResponse;
+export type BearerOptions = Partial<Omit<api.GetTokenResponse, 'access_token'>> & {
+    refreshAccessToken?: RefreshAccessTokenFunction;
+    access_token: core.Supplier<string>;
+};
+export declare class RefreshBearerProvider {
+    private readonly BUFFER_IN_MINUTES;
+    private _accessToken;
+    private _refreshToken;
+    private _refreshAccessToken;
+    private _expiresAt;
+    private _refreshExpiresAt;
+    constructor({ access_token, refreshAccessToken, refresh_token, refresh_expires_in, expires_in, }: BearerOptions);
+    getToken(): Promise<string>;
+    private refresh;
+    private getExpiresAt;
+}
+export {};

package/dist/esm/custom/RefreshBearerProvider.mjs

@@ -0,0 +1,48 @@
+/**
+ * RefreshBearerProvider used as a replacement of OAuthTokenProvider, in case when accessToken from outside of library was used instead of Client credentials.
+ */
+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());
+    });
+};
+import * as core from "../core/index.mjs";
+export class RefreshBearerProvider {
+    constructor({ access_token, refreshAccessToken, refresh_token, refresh_expires_in, expires_in, }) {
+        this.BUFFER_IN_MINUTES = 2;
+        this._expiresAt = this.getExpiresAt(expires_in, this.BUFFER_IN_MINUTES);
+        this._refreshExpiresAt = this.getExpiresAt(refresh_expires_in, 0);
+        this._accessToken = access_token;
+        this._refreshToken = refresh_token;
+        this._refreshAccessToken = refreshAccessToken;
+    }
+    getToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._accessToken && this._expiresAt > new Date()) {
+                return core.Supplier.get(this._accessToken);
+            }
+            return this.refresh();
+        });
+    }
+    refresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._refreshAccessToken || this._refreshToken && this._refreshExpiresAt < new Date()) {
+                return core.Supplier.get(this._accessToken);
+            }
+            const tokenResponse = yield this._refreshAccessToken(this._refreshToken);
+            this._accessToken = tokenResponse.access_token;
+            this._expiresAt = this.getExpiresAt(tokenResponse.expires_in, this.BUFFER_IN_MINUTES);
+            this._refreshToken = tokenResponse.refresh_token;
+            this._refreshExpiresAt = this.getExpiresAt(tokenResponse.refresh_expires_in, 0);
+            return this._accessToken;
+        });
+    }
+    getExpiresAt(expiresInSeconds = 0, bufferInMinutes = this.BUFFER_IN_MINUTES) {
+        const now = new Date();
+        return new Date(now.getTime() + expiresInSeconds * 1000 - bufferInMinutes * 60 * 1000);
+    }
+}