@speechall/sdk 0.0.1 → 2.0.4

package/dist/esm/api.js

@@ -1,574 +0,0 @@
-import globalAxios from 'axios';
-import { DUMMY_BASE_URL, assertParamExists, setBearerAuthToObject, setSearchParams, serializeDataIfNeeded, toPathString, createRequestFunction } from './common.js';
-import { BASE_PATH, COLLECTION_FORMATS, BaseAPI, operationServerMap } from './base.js';
-export const ExactRuleKindEnum = {
-    Exact: 'exact'
-};
-export const OpenAIAudioResponseFormat = {
-    Json: 'json',
-    Text: 'text',
-    Srt: 'srt',
-    VerboseJson: 'verbose_json',
-    Vtt: 'vtt'
-};
-export const RegexGroupRuleKindEnum = {
-    RegexGroup: 'regex_group'
-};
-export const RegexGroupRuleFlagsEnum = {
-    I: 'i',
-    M: 'm',
-    S: 's',
-    X: 'x',
-    U: 'u'
-};
-export const RegexRuleKindEnum = {
-    Regex: 'regex'
-};
-export const RegexRuleFlagsEnum = {
-    I: 'i',
-    M: 'm',
-    S: 's',
-    X: 'x',
-    U: 'u'
-};
-export const SpeechToTextModelModelTypeEnum = {
-    General: 'general',
-    PhoneCall: 'phone_call',
-    Video: 'video',
-    CommandAndSearch: 'command_and_search',
-    Medical: 'medical',
-    Legal: 'legal',
-    Voicemail: 'voicemail',
-    Meeting: 'meeting'
-};
-export const SpeechToTextModelAccuracyTierEnum = {
-    Basic: 'basic',
-    Standard: 'standard',
-    Enhanced: 'enhanced',
-    Premium: 'premium'
-};
-export const TranscriptLanguageCode = {
-    Auto: 'auto',
-    En: 'en',
-    EnAu: 'en_au',
-    EnUk: 'en_uk',
-    EnUs: 'en_us',
-    Af: 'af',
-    Am: 'am',
-    Ar: 'ar',
-    As: 'as',
-    Az: 'az',
-    Ba: 'ba',
-    Be: 'be',
-    Bg: 'bg',
-    Bn: 'bn',
-    Bo: 'bo',
-    Br: 'br',
-    Bs: 'bs',
-    Ca: 'ca',
-    Cs: 'cs',
-    Cy: 'cy',
-    Da: 'da',
-    De: 'de',
-    El: 'el',
-    Es: 'es',
-    Et: 'et',
-    Eu: 'eu',
-    Fa: 'fa',
-    Fi: 'fi',
-    Fo: 'fo',
-    Fr: 'fr',
-    Gl: 'gl',
-    Gu: 'gu',
-    Ha: 'ha',
-    Haw: 'haw',
-    He: 'he',
-    Hi: 'hi',
-    Hr: 'hr',
-    Ht: 'ht',
-    Hu: 'hu',
-    Hy: 'hy',
-    Id: 'id',
-    Is: 'is',
-    It: 'it',
-    Ja: 'ja',
-    Jw: 'jw',
-    Ka: 'ka',
-    Kk: 'kk',
-    Km: 'km',
-    Kn: 'kn',
-    Ko: 'ko',
-    La: 'la',
-    Lb: 'lb',
-    Ln: 'ln',
-    Lo: 'lo',
-    Lt: 'lt',
-    Lv: 'lv',
-    Mg: 'mg',
-    Mi: 'mi',
-    Mk: 'mk',
-    Ml: 'ml',
-    Mn: 'mn',
-    Mr: 'mr',
-    Ms: 'ms',
-    Mt: 'mt',
-    My: 'my',
-    Ne: 'ne',
-    Nl: 'nl',
-    Nn: 'nn',
-    False: 'false',
-    Oc: 'oc',
-    Pa: 'pa',
-    Pl: 'pl',
-    Ps: 'ps',
-    Pt: 'pt',
-    Ro: 'ro',
-    Ru: 'ru',
-    Sa: 'sa',
-    Sd: 'sd',
-    Si: 'si',
-    Sk: 'sk',
-    Sl: 'sl',
-    Sn: 'sn',
-    So: 'so',
-    Sq: 'sq',
-    Sr: 'sr',
-    Su: 'su',
-    Sv: 'sv',
-    Sw: 'sw',
-    Ta: 'ta',
-    Te: 'te',
-    Tg: 'tg',
-    Th: 'th',
-    Tk: 'tk',
-    Tl: 'tl',
-    Tr: 'tr',
-    Tt: 'tt',
-    Uk: 'uk',
-    Ur: 'ur',
-    Uz: 'uz',
-    Vi: 'vi',
-    Yi: 'yi',
-    Yo: 'yo',
-    Zh: 'zh'
-};
-export const TranscriptOutputFormat = {
-    Text: 'text',
-    JsonText: 'json_text',
-    Json: 'json',
-    Srt: 'srt',
-    Vtt: 'vtt'
-};
-export const TranscriptionModelIdentifier = {
-    AmazonTranscribe: 'amazon.transcribe',
-    AssemblyaiBest: 'assemblyai.best',
-    AssemblyaiNano: 'assemblyai.nano',
-    AzureStandard: 'azure.standard',
-    CloudflareWhisper: 'cloudflare.whisper',
-    DeepgramBase: 'deepgram.base',
-    DeepgramBaseConversationalai: 'deepgram.base-conversationalai',
-    DeepgramBaseFinance: 'deepgram.base-finance',
-    DeepgramBaseGeneral: 'deepgram.base-general',
-    DeepgramBaseMeeting: 'deepgram.base-meeting',
-    DeepgramBasePhonecall: 'deepgram.base-phonecall',
-    DeepgramBaseVideo: 'deepgram.base-video',
-    DeepgramBaseVoicemail: 'deepgram.base-voicemail',
-    DeepgramEnhanced: 'deepgram.enhanced',
-    DeepgramEnhancedFinance: 'deepgram.enhanced-finance',
-    DeepgramEnhancedGeneral: 'deepgram.enhanced-general',
-    DeepgramEnhancedMeeting: 'deepgram.enhanced-meeting',
-    DeepgramEnhancedPhonecall: 'deepgram.enhanced-phonecall',
-    DeepgramNova: 'deepgram.nova',
-    DeepgramNova2: 'deepgram.nova-2',
-    DeepgramNova2Atc: 'deepgram.nova-2-atc',
-    DeepgramNova2Automotive: 'deepgram.nova-2-automotive',
-    DeepgramNova2Conversationalai: 'deepgram.nova-2-conversationalai',
-    DeepgramNova2Drivethru: 'deepgram.nova-2-drivethru',
-    DeepgramNova2Finance: 'deepgram.nova-2-finance',
-    DeepgramNova2General: 'deepgram.nova-2-general',
-    DeepgramNova2Medical: 'deepgram.nova-2-medical',
-    DeepgramNova2Meeting: 'deepgram.nova-2-meeting',
-    DeepgramNova2Phonecall: 'deepgram.nova-2-phonecall',
-    DeepgramNova2Video: 'deepgram.nova-2-video',
-    DeepgramNova2Voicemail: 'deepgram.nova-2-voicemail',
-    DeepgramNova3: 'deepgram.nova-3',
-    DeepgramNovaGeneral: 'deepgram.nova-general',
-    DeepgramNovaPhonecall: 'deepgram.nova-phonecall',
-    DeepgramWhisper: 'deepgram.whisper',
-    DeepgramWhisperBase: 'deepgram.whisper-base',
-    DeepgramWhisperLarge: 'deepgram.whisper-large',
-    DeepgramWhisperMedium: 'deepgram.whisper-medium',
-    DeepgramWhisperSmall: 'deepgram.whisper-small',
-    DeepgramWhisperTiny: 'deepgram.whisper-tiny',
-    FalaiWhisper: 'falai.whisper',
-    FalaiWizper: 'falai.wizper',
-    FireworksaiWhisperV3: 'fireworksai.whisper-v3',
-    FireworksaiWhisperV3Turbo: 'fireworksai.whisper-v3-turbo',
-    GladiaStandard: 'gladia.standard',
-    GoogleEnhanced: 'google.enhanced',
-    GoogleStandard: 'google.standard',
-    GroqDistilWhisperLargeV3En: 'groq.distil-whisper-large-v3-en',
-    GroqWhisperLargeV3: 'groq.whisper-large-v3',
-    GroqWhisperLargeV3Turbo: 'groq.whisper-large-v3-turbo',
-    IbmStandard: 'ibm.standard',
-    OpenaiWhisper1: 'openai.whisper-1',
-    OpenaiGpt4oTranscribe: 'openai.gpt-4o-transcribe',
-    OpenaiGpt4oMiniTranscribe: 'openai.gpt-4o-mini-transcribe',
-    RevaiMachine: 'revai.machine',
-    SpeechmaticsEnhanced: 'speechmatics.enhanced',
-    SpeechmaticsStandard: 'speechmatics.standard'
-};
-export const TranscriptionOptionsTimestampGranularityEnum = {
-    Word: 'word',
-    Segment: 'segment'
-};
-export const TranscriptionProvider = {
-    Amazon: 'amazon',
-    Assemblyai: 'assemblyai',
-    Azure: 'azure',
-    Cloudflare: 'cloudflare',
-    Deepgram: 'deepgram',
-    Falai: 'falai',
-    Fireworksai: 'fireworksai',
-    Gladia: 'gladia',
-    Google: 'google',
-    Groq: 'groq',
-    Ibm: 'ibm',
-    Openai: 'openai',
-    Revai: 'revai',
-    Speechmatics: 'speechmatics'
-};
-export const OpenAICompatibleSpeechToTextApiAxiosParamCreator = function (configuration) {
-    return {
-        openaiCompatibleCreateTranscription: async (file, model, language, prompt, responseFormat, temperature, timestampGranularities, options = {}) => {
-            assertParamExists('openaiCompatibleCreateTranscription', 'file', file);
-            assertParamExists('openaiCompatibleCreateTranscription', 'model', model);
-            const localVarPath = `/openai-compatible/audio/transcriptions`;
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            const localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (file !== undefined) {
-                localVarFormParams.append('file', file);
-            }
-            if (model !== undefined) {
-                localVarFormParams.append('model', model);
-            }
-            if (language !== undefined) {
-                localVarFormParams.append('language', language);
-            }
-            if (prompt !== undefined) {
-                localVarFormParams.append('prompt', prompt);
-            }
-            if (responseFormat !== undefined) {
-                localVarFormParams.append('response_format', responseFormat);
-            }
-            if (temperature !== undefined) {
-                localVarFormParams.append('temperature', temperature);
-            }
-            if (timestampGranularities) {
-                localVarFormParams.append('timestamp_granularities[]', timestampGranularities.join(COLLECTION_FORMATS.csv));
-            }
-            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = localVarFormParams;
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        openaiCompatibleCreateTranslation: async (file, model, prompt, responseFormat, temperature, options = {}) => {
-            assertParamExists('openaiCompatibleCreateTranslation', 'file', file);
-            assertParamExists('openaiCompatibleCreateTranslation', 'model', model);
-            const localVarPath = `/openai-compatible/audio/translations`;
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            const localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (file !== undefined) {
-                localVarFormParams.append('file', file);
-            }
-            if (model !== undefined) {
-                localVarFormParams.append('model', new Blob([JSON.stringify(model)], { type: "application/json", }));
-            }
-            if (prompt !== undefined) {
-                localVarFormParams.append('prompt', prompt);
-            }
-            if (responseFormat !== undefined) {
-                localVarFormParams.append('response_format', responseFormat);
-            }
-            if (temperature !== undefined) {
-                localVarFormParams.append('temperature', temperature);
-            }
-            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = localVarFormParams;
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-    };
-};
-export const OpenAICompatibleSpeechToTextApiFp = function (configuration) {
-    const localVarAxiosParamCreator = OpenAICompatibleSpeechToTextApiAxiosParamCreator(configuration);
-    return {
-        async openaiCompatibleCreateTranscription(file, model, language, prompt, responseFormat, temperature, timestampGranularities, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.openaiCompatibleCreateTranscription(file, model, language, prompt, responseFormat, temperature, timestampGranularities, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['OpenAICompatibleSpeechToTextApi.openaiCompatibleCreateTranscription']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        async openaiCompatibleCreateTranslation(file, model, prompt, responseFormat, temperature, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.openaiCompatibleCreateTranslation(file, model, prompt, responseFormat, temperature, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['OpenAICompatibleSpeechToTextApi.openaiCompatibleCreateTranslation']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-    };
-};
-export const OpenAICompatibleSpeechToTextApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = OpenAICompatibleSpeechToTextApiFp(configuration);
-    return {
-        openaiCompatibleCreateTranscription(file, model, language, prompt, responseFormat, temperature, timestampGranularities, options) {
-            return localVarFp.openaiCompatibleCreateTranscription(file, model, language, prompt, responseFormat, temperature, timestampGranularities, options).then((request) => request(axios, basePath));
-        },
-        openaiCompatibleCreateTranslation(file, model, prompt, responseFormat, temperature, options) {
-            return localVarFp.openaiCompatibleCreateTranslation(file, model, prompt, responseFormat, temperature, options).then((request) => request(axios, basePath));
-        },
-    };
-};
-export class OpenAICompatibleSpeechToTextApi extends BaseAPI {
-    openaiCompatibleCreateTranscription(file, model, language, prompt, responseFormat, temperature, timestampGranularities, options) {
-        return OpenAICompatibleSpeechToTextApiFp(this.configuration).openaiCompatibleCreateTranscription(file, model, language, prompt, responseFormat, temperature, timestampGranularities, options).then((request) => request(this.axios, this.basePath));
-    }
-    openaiCompatibleCreateTranslation(file, model, prompt, responseFormat, temperature, options) {
-        return OpenAICompatibleSpeechToTextApiFp(this.configuration).openaiCompatibleCreateTranslation(file, model, prompt, responseFormat, temperature, options).then((request) => request(this.axios, this.basePath));
-    }
-}
-export const OpenaiCompatibleCreateTranscriptionTimestampGranularitiesEnum = {
-    Word: 'word',
-    Segment: 'segment'
-};
-export const ReplacementRulesApiAxiosParamCreator = function (configuration) {
-    return {
-        createReplacementRuleset: async (createReplacementRulesetRequest, options = {}) => {
-            assertParamExists('createReplacementRuleset', 'createReplacementRulesetRequest', createReplacementRulesetRequest);
-            const localVarPath = `/replacement-rulesets`;
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(createReplacementRulesetRequest, localVarRequestOptions, configuration);
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-    };
-};
-export const ReplacementRulesApiFp = function (configuration) {
-    const localVarAxiosParamCreator = ReplacementRulesApiAxiosParamCreator(configuration);
-    return {
-        async createReplacementRuleset(createReplacementRulesetRequest, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.createReplacementRuleset(createReplacementRulesetRequest, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['ReplacementRulesApi.createReplacementRuleset']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-    };
-};
-export const ReplacementRulesApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = ReplacementRulesApiFp(configuration);
-    return {
-        createReplacementRuleset(createReplacementRulesetRequest, options) {
-            return localVarFp.createReplacementRuleset(createReplacementRulesetRequest, options).then((request) => request(axios, basePath));
-        },
-    };
-};
-export class ReplacementRulesApi extends BaseAPI {
-    createReplacementRuleset(createReplacementRulesetRequest, options) {
-        return ReplacementRulesApiFp(this.configuration).createReplacementRuleset(createReplacementRulesetRequest, options).then((request) => request(this.axios, this.basePath));
-    }
-}
-export const SpeechToTextApiAxiosParamCreator = function (configuration) {
-    return {
-        listSpeechToTextModels: async (options = {}) => {
-            const localVarPath = `/speech-to-text-models`;
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        transcribe: async (model, body, language, outputFormat, rulesetId, punctuation, timestampGranularity, diarization, initialPrompt, temperature, smartFormat, speakersExpected, customVocabulary, options = {}) => {
-            assertParamExists('transcribe', 'model', model);
-            assertParamExists('transcribe', 'body', body);
-            const localVarPath = `/transcribe`;
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            if (model !== undefined) {
-                localVarQueryParameter['model'] = model;
-            }
-            if (language !== undefined) {
-                localVarQueryParameter['language'] = language;
-            }
-            if (outputFormat !== undefined) {
-                localVarQueryParameter['output_format'] = outputFormat;
-            }
-            if (rulesetId !== undefined) {
-                localVarQueryParameter['ruleset_id'] = rulesetId;
-            }
-            if (punctuation !== undefined) {
-                localVarQueryParameter['punctuation'] = punctuation;
-            }
-            if (timestampGranularity !== undefined) {
-                localVarQueryParameter['timestamp_granularity'] = timestampGranularity;
-            }
-            if (diarization !== undefined) {
-                localVarQueryParameter['diarization'] = diarization;
-            }
-            if (initialPrompt !== undefined) {
-                localVarQueryParameter['initial_prompt'] = initialPrompt;
-            }
-            if (temperature !== undefined) {
-                localVarQueryParameter['temperature'] = temperature;
-            }
-            if (smartFormat !== undefined) {
-                localVarQueryParameter['smart_format'] = smartFormat;
-            }
-            if (speakersExpected !== undefined) {
-                localVarQueryParameter['speakers_expected'] = speakersExpected;
-            }
-            if (customVocabulary) {
-                localVarQueryParameter['custom_vocabulary'] = customVocabulary;
-            }
-            localVarHeaderParameter['Content-Type'] = 'audio/*';
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(body, localVarRequestOptions, configuration);
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-        transcribeRemote: async (transcriptionOptions, options = {}) => {
-            assertParamExists('transcribeRemote', 'transcriptionOptions', transcriptionOptions);
-            const localVarPath = `/transcribe-remote`;
-            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-            let baseOptions;
-            if (configuration) {
-                baseOptions = configuration.baseOptions;
-            }
-            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
-            const localVarHeaderParameter = {};
-            const localVarQueryParameter = {};
-            await setBearerAuthToObject(localVarHeaderParameter, configuration);
-            localVarHeaderParameter['Content-Type'] = 'application/json';
-            setSearchParams(localVarUrlObj, localVarQueryParameter);
-            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(transcriptionOptions, localVarRequestOptions, configuration);
-            return {
-                url: toPathString(localVarUrlObj),
-                options: localVarRequestOptions,
-            };
-        },
-    };
-};
-export const SpeechToTextApiFp = function (configuration) {
-    const localVarAxiosParamCreator = SpeechToTextApiAxiosParamCreator(configuration);
-    return {
-        async listSpeechToTextModels(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listSpeechToTextModels(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['SpeechToTextApi.listSpeechToTextModels']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        async transcribe(model, body, language, outputFormat, rulesetId, punctuation, timestampGranularity, diarization, initialPrompt, temperature, smartFormat, speakersExpected, customVocabulary, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.transcribe(model, body, language, outputFormat, rulesetId, punctuation, timestampGranularity, diarization, initialPrompt, temperature, smartFormat, speakersExpected, customVocabulary, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['SpeechToTextApi.transcribe']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-        async transcribeRemote(transcriptionOptions, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.transcribeRemote(transcriptionOptions, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['SpeechToTextApi.transcribeRemote']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-    };
-};
-export const SpeechToTextApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = SpeechToTextApiFp(configuration);
-    return {
-        listSpeechToTextModels(options) {
-            return localVarFp.listSpeechToTextModels(options).then((request) => request(axios, basePath));
-        },
-        transcribe(model, body, language, outputFormat, rulesetId, punctuation, timestampGranularity, diarization, initialPrompt, temperature, smartFormat, speakersExpected, customVocabulary, options) {
-            return localVarFp.transcribe(model, body, language, outputFormat, rulesetId, punctuation, timestampGranularity, diarization, initialPrompt, temperature, smartFormat, speakersExpected, customVocabulary, options).then((request) => request(axios, basePath));
-        },
-        transcribeRemote(transcriptionOptions, options) {
-            return localVarFp.transcribeRemote(transcriptionOptions, options).then((request) => request(axios, basePath));
-        },
-    };
-};
-export class SpeechToTextApi extends BaseAPI {
-    listSpeechToTextModels(options) {
-        return SpeechToTextApiFp(this.configuration).listSpeechToTextModels(options).then((request) => request(this.axios, this.basePath));
-    }
-    transcribe(model, body, language, outputFormat, rulesetId, punctuation, timestampGranularity, diarization, initialPrompt, temperature, smartFormat, speakersExpected, customVocabulary, options) {
-        return SpeechToTextApiFp(this.configuration).transcribe(model, body, language, outputFormat, rulesetId, punctuation, timestampGranularity, diarization, initialPrompt, temperature, smartFormat, speakersExpected, customVocabulary, options).then((request) => request(this.axios, this.basePath));
-    }
-    transcribeRemote(transcriptionOptions, options) {
-        return SpeechToTextApiFp(this.configuration).transcribeRemote(transcriptionOptions, options).then((request) => request(this.axios, this.basePath));
-    }
-}
-export const TranscribeTimestampGranularityEnum = {
-    Word: 'word',
-    Segment: 'segment'
-};

package/dist/esm/base.js

@@ -1,27 +0,0 @@
-import globalAxios from 'axios';
-export const BASE_PATH = "https://api.speechall.com/v1".replace(/\/+$/, "");
-export const COLLECTION_FORMATS = {
-    csv: ",",
-    ssv: " ",
-    tsv: "\t",
-    pipes: "|",
-};
-export class BaseAPI {
-    constructor(configuration, basePath = BASE_PATH, axios = globalAxios) {
-        this.basePath = basePath;
-        this.axios = axios;
-        if (configuration) {
-            this.configuration = configuration;
-            this.basePath = configuration.basePath ?? basePath;
-        }
-    }
-}
-;
-export class RequiredError extends Error {
-    constructor(field, msg) {
-        super(msg);
-        this.field = field;
-        this.name = "RequiredError";
-    }
-}
-export const operationServerMap = {};

package/dist/esm/common.js

@@ -1,79 +0,0 @@
-import { RequiredError } from "./base.js";
-export const DUMMY_BASE_URL = 'https://example.com';
-export const assertParamExists = function (functionName, paramName, paramValue) {
-    if (paramValue === null || paramValue === undefined) {
-        throw new RequiredError(paramName, `Required parameter ${paramName} was null or undefined when calling ${functionName}.`);
-    }
-};
-export const setApiKeyToObject = async function (object, keyParamName, configuration) {
-    if (configuration && configuration.apiKey) {
-        const localVarApiKeyValue = typeof configuration.apiKey === 'function'
-            ? await configuration.apiKey(keyParamName)
-            : await configuration.apiKey;
-        object[keyParamName] = localVarApiKeyValue;
-    }
-};
-export const setBasicAuthToObject = function (object, configuration) {
-    if (configuration && (configuration.username || configuration.password)) {
-        object["auth"] = { username: configuration.username, password: configuration.password };
-    }
-};
-export const setBearerAuthToObject = async function (object, configuration) {
-    if (configuration && configuration.accessToken) {
-        const accessToken = typeof configuration.accessToken === 'function'
-            ? await configuration.accessToken()
-            : await configuration.accessToken;
-        object["Authorization"] = "Bearer " + accessToken;
-    }
-};
-export const setOAuthToObject = async function (object, name, scopes, configuration) {
-    if (configuration && configuration.accessToken) {
-        const localVarAccessTokenValue = typeof configuration.accessToken === 'function'
-            ? await configuration.accessToken(name, scopes)
-            : await configuration.accessToken;
-        object["Authorization"] = "Bearer " + localVarAccessTokenValue;
-    }
-};
-function setFlattenedQueryParams(urlSearchParams, parameter, key = "") {
-    if (parameter == null)
-        return;
-    if (typeof parameter === "object") {
-        if (Array.isArray(parameter)) {
-            parameter.forEach(item => setFlattenedQueryParams(urlSearchParams, item, key));
-        }
-        else {
-            Object.keys(parameter).forEach(currentKey => setFlattenedQueryParams(urlSearchParams, parameter[currentKey], `${key}${key !== '' ? '.' : ''}${currentKey}`));
-        }
-    }
-    else {
-        if (urlSearchParams.has(key)) {
-            urlSearchParams.append(key, parameter);
-        }
-        else {
-            urlSearchParams.set(key, parameter);
-        }
-    }
-}
-export const setSearchParams = function (url, ...objects) {
-    const searchParams = new URLSearchParams(url.search);
-    setFlattenedQueryParams(searchParams, objects);
-    url.search = searchParams.toString();
-};
-export const serializeDataIfNeeded = function (value, requestOptions, configuration) {
-    const nonString = typeof value !== 'string';
-    const needsSerialization = nonString && configuration && configuration.isJsonMime
-        ? configuration.isJsonMime(requestOptions.headers['Content-Type'])
-        : nonString;
-    return needsSerialization
-        ? JSON.stringify(value !== undefined ? value : {})
-        : (value || "");
-};
-export const toPathString = function (url) {
-    return url.pathname + url.search + url.hash;
-};
-export const createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, configuration) {
-    return (axios = globalAxios, basePath = BASE_PATH) => {
-        const axiosRequestArgs = { ...axiosArgs.options, url: (axios.defaults.baseURL ? '' : configuration?.basePath ?? basePath) + axiosArgs.url };
-        return axios.request(axiosRequestArgs);
-    };
-};