@supertone/supertone 0.1.2 → 0.1.3

package/src/lib/config.ts

@@ -11,58 +11,58 @@ import { Params, pathToFunc } from "./url.js";
  * Contains the list of servers available to the SDK
  */
 export const ServerList = [
-  /**
-   * Production
-   */
-  "https://supertoneapi.com",
+	/**
+	 * Production
+	 */
+	"https://supertoneapi.com",
 ] as const;
 
 export type SDKOptions = {
-  apiKey?: string | (() => Promise<string>) | undefined;
+	apiKey?: string | (() => Promise<string>) | undefined;
 
-  httpClient?: HTTPClient;
-  /**
-   * Allows overriding the default server used by the SDK
-   */
-  serverIdx?: number | undefined;
-  /**
-   * Allows overriding the default server URL used by the SDK
-   */
-  serverURL?: string | undefined;
-  /**
-   * Allows overriding the default user agent used by the SDK
-   */
-  userAgent?: string | undefined;
-  /**
-   * Allows overriding the default retry config used by the SDK
-   */
-  retryConfig?: RetryConfig;
-  timeoutMs?: number;
-  debugLogger?: Logger;
+	httpClient?: HTTPClient;
+	/**
+	 * Allows overriding the default server used by the SDK
+	 */
+	serverIdx?: number | undefined;
+	/**
+	 * Allows overriding the default server URL used by the SDK
+	 */
+	serverURL?: string | undefined;
+	/**
+	 * Allows overriding the default user agent used by the SDK
+	 */
+	userAgent?: string | undefined;
+	/**
+	 * Allows overriding the default retry config used by the SDK
+	 */
+	retryConfig?: RetryConfig;
+	timeoutMs?: number;
+	debugLogger?: Logger;
 };
 
 export function serverURLFromOptions(options: SDKOptions): URL | null {
-  let serverURL = options.serverURL;
+	let serverURL = options.serverURL;
 
-  const params: Params = {};
+	const params: Params = {};
 
-  if (!serverURL) {
-    const serverIdx = options.serverIdx ?? 0;
-    if (serverIdx < 0 || serverIdx >= ServerList.length) {
-      throw new Error(`Invalid server index ${serverIdx}`);
-    }
-    serverURL = ServerList[serverIdx] || "";
-  }
+	if (!serverURL) {
+		const serverIdx = options.serverIdx ?? 0;
+		if (serverIdx < 0 || serverIdx >= ServerList.length) {
+			throw new Error(`Invalid server index ${serverIdx}`);
+		}
+		serverURL = ServerList[serverIdx] || "";
+	}
 
-  const u = pathToFunc(serverURL)(params);
-  return new URL(u);
+	const u = pathToFunc(serverURL)(params);
+	return new URL(u);
 }
 
 export const SDK_METADATA = {
-  language: "typescript",
-  openapiDocVersion: "0.8.69",
-  sdkVersion: "0.1.2",
-  genVersion: "2.686.7",
-  userAgent:
-    "speakeasy-sdk/typescript 0.1.2 2.686.7 0.8.69 @supertone/supertone",
+	language: "typescript",
+	openapiDocVersion: "0.8.69",
+	sdkVersion: "0.1.3",
+	genVersion: "2.686.7",
+	userAgent:
+		"speakeasy-sdk/typescript 0.1.2 2.686.7 0.8.69 @supertone/supertone",
 } as const;

package/src/lib/custom_utils/index.ts

@@ -11,6 +11,13 @@ export * from "./constants.js";
 // Export text utilities
 export { chunkText, extractAudioFromNdjson } from "./text_utils.js";
 
+// Export pronunciation utilities
+export {
+	applyPronunciationDictionary,
+	PronunciationDictionaryValidationError,
+	type PronunciationDictionaryEntry,
+} from "./pronunciation_utils.js";
+
 // Export audio utilities
 export {
 	mergeWavBinary,

package/src/lib/custom_utils/pronunciation_utils.ts

@@ -0,0 +1,193 @@
+/**
+ * Pronunciation dictionary substitution utilities.
+ *
+ * Mirrors the Python implementation policy:
+ * - Apply rules in input order
+ * - partial_match=false: word-boundary exact matches only
+ * - partial_match=true: substring matches (no boundaries)
+ * - No re-substitution: replaced segments are shielded via opaque tokens
+ *
+ * Validation:
+ * - pronunciation_dictionary omitted/undefined/null -> return original text
+ * - pronunciation_dictionary must be an array of objects
+ * - each object must have: text (string, non-empty), pronunciation (string, non-empty), partial_match (boolean)
+ */
+
+export class PronunciationDictionaryValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "PronunciationDictionaryValidationError";
+  }
+}
+
+export type PronunciationDictionaryEntry = {
+  text: string;
+  pronunciation: string;
+  partial_match: boolean;
+};
+
+export function applyPronunciationDictionary(
+  text: string,
+  pronunciation_dictionary?: unknown
+): string {
+  // Match Python behavior: return early for null, undefined, or empty array
+  if (
+    pronunciation_dictionary == null ||
+    (Array.isArray(pronunciation_dictionary) &&
+      pronunciation_dictionary.length === 0)
+  ) {
+    return text;
+  }
+
+  if (typeof text !== "string") {
+    throw new PronunciationDictionaryValidationError(
+      `\`text\` must be string, got ${typeof text}`
+    );
+  }
+
+  if (!Array.isArray(pronunciation_dictionary)) {
+    throw new PronunciationDictionaryValidationError(
+      "`pronunciation_dictionary` must be an array of objects"
+    );
+  }
+
+  // Prevent re-substitution:
+  // replace matches with unique opaque tokens first,
+  // then expand tokens to pronunciations at the end.
+  const tokenToPronunciation = new Map<string, string>();
+  let working = text;
+
+  for (let idx = 0; idx < pronunciation_dictionary.length; idx++) {
+    const entry = validateEntry(pronunciation_dictionary[idx], idx);
+    const src = entry.text;
+    const dst = entry.pronunciation;
+    const partial = entry.partial_match;
+
+    const token = makeUniqueToken(idx, working, tokenToPronunciation);
+
+    if (partial) {
+      const re = new RegExp(escapeRegExp(src), "g");
+      const newWorking = working.replace(re, token);
+      if (newWorking === working) continue; // No match found
+      tokenToPronunciation.set(token, dst);
+      working = newWorking;
+      continue;
+    }
+
+    // Exact match with word-boundary semantics (Unicode-aware-ish).
+    // Python uses Unicode \w; in JS, \w is ASCII-only. To mirror behavior better across scripts,
+    // we define "word char" as: letter or number or underscore.
+    //
+    // We avoid lookbehind for broader runtime compatibility by capturing the left boundary.
+    //
+    // Pattern: (^|[^WORD_CHARS]) (SRC) (?=[^WORD_CHARS]|$)
+    // (IMPORTANT) WORD_CHARS must not include surrounding [] because we embed it into other [].
+    const WORD_CHARS = "\\p{L}\\p{N}_";
+    const srcEsc = escapeRegExp(src);
+    const pattern = `(^|[^${WORD_CHARS}])(${srcEsc})(?=[^${WORD_CHARS}]|$)`;
+    const re = new RegExp(pattern, "gu");
+
+    // Replace keeping the left boundary (group 1)
+    const newWorking = working.replace(re, `$1${token}`);
+    if (newWorking === working) continue; // No match found
+    tokenToPronunciation.set(token, dst);
+    working = newWorking;
+  }
+
+  // Expand tokens into pronunciations.
+  for (const [token, pron] of tokenToPronunciation.entries()) {
+    working = working.split(token).join(pron);
+  }
+
+  return working;
+}
+
+function validateEntry(raw: unknown, idx: number): PronunciationDictionaryEntry {
+  if (raw == null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new PronunciationDictionaryValidationError(
+      `pronunciation_dictionary[${idx}] must be an object, got ${
+        raw === null ? "null" : Array.isArray(raw) ? "array" : typeof raw
+      }`
+    );
+  }
+
+  const obj = raw as Record<string, unknown>;
+  const missing: string[] = [];
+  if (!("text" in obj)) missing.push("text");
+  if (!("pronunciation" in obj)) missing.push("pronunciation");
+  if (!("partial_match" in obj)) missing.push("partial_match");
+  if (missing.length) {
+    throw new PronunciationDictionaryValidationError(
+      `pronunciation_dictionary[${idx}] missing required field(s): ${missing.join(", ")}`
+    );
+  }
+
+  const src = obj["text"];
+  const dst = obj["pronunciation"];
+  const partial = obj["partial_match"];
+
+  if (typeof src !== "string") {
+    throw new PronunciationDictionaryValidationError(
+      `pronunciation_dictionary[${idx}].text must be string, got ${typeof src}`
+    );
+  }
+  if (typeof dst !== "string") {
+    throw new PronunciationDictionaryValidationError(
+      `pronunciation_dictionary[${idx}].pronunciation must be string, got ${typeof dst}`
+    );
+  }
+  if (typeof partial !== "boolean") {
+    throw new PronunciationDictionaryValidationError(
+      `pronunciation_dictionary[${idx}].partial_match must be boolean, got ${typeof partial}`
+    );
+  }
+
+  if (src === "") {
+    throw new PronunciationDictionaryValidationError(
+      `pronunciation_dictionary[${idx}].text must not be empty`
+    );
+  }
+  if (dst === "") {
+    throw new PronunciationDictionaryValidationError(
+      `pronunciation_dictionary[${idx}].pronunciation must not be empty`
+    );
+  }
+
+  return { text: src, pronunciation: dst, partial_match: partial };
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function makeUniqueToken(
+  idx: number,
+  working: string,
+  existing: Map<string, string>
+): string {
+  // Private Use Area markers to minimize collision with typical text.
+  const base = `\uE000PD${idx}\uE001`;
+  if (!working.includes(base) && !existing.has(base)) return base;
+
+  while (true) {
+    const suffix = safeRandomHex();
+    const token = `\uE000PD${idx}_${suffix}\uE001`;
+    if (!working.includes(token) && !existing.has(token)) return token;
+  }
+}
+
+function safeRandomHex(): string {
+  // Prefer crypto.randomUUID when available (browser / modern runtimes)
+  const c = (globalThis as any).crypto;
+  if (c && typeof c.randomUUID === "function") {
+    return String(c.randomUUID()).replace(/-/g, "");
+  }
+  // Fallback: not cryptographically strong, but fine for uniqueness tokenization.
+  return (
+    Math.random().toString(16).slice(2) +
+    Math.random().toString(16).slice(2) +
+    Date.now().toString(16)
+  );
+}
+
+

package/src/lib/custom_utils/text_utils.ts

@@ -7,6 +7,28 @@
 
 import { DEFAULT_MAX_TEXT_LENGTH } from "./constants.js";
 
+/**
+ * Sentence-ending punctuation pattern for multilingual support.
+ *
+ * Supported languages: English, Korean, Japanese, Bulgarian, Czech, Danish,
+ * Greek, Spanish, Estonian, Finnish, Hungarian, Italian, Dutch, Polish,
+ * Portuguese, Romanian, Arabic, German, French, Hindi, Indonesian, Russian,
+ * Vietnamese, Chinese, Thai, and more.
+ *
+ * Punctuation groups:
+ * - ASCII basics: . ! ? ; :
+ * - Ellipsis: … (U+2026), ‥ (U+2025)
+ * - CJK fullwidth: 。！？；：｡、
+ * - Arabic/Urdu: ؟ ؛ ۔ ،
+ * - Devanagari (Hindi/Sanskrit): । ॥
+ * - Greek question mark: ; (U+037E)
+ */
+const SENTENCE_PUNCTUATION = ".!?;:…‥。！？；：｡、؟؛۔،।॥\u037E";
+const SENTENCE_SPLIT_PATTERN = new RegExp(
+	`([${SENTENCE_PUNCTUATION}]+\\s*)`,
+	"u"
+);
+
 /**
  * Check if text contains spaces (to determine if word-based splitting is possible)
  *
@@ -104,7 +126,7 @@ function splitOversizedChunk(chunk: string, maxLength: number): string[] {
  * word/character boundaries when necessary.
  *
  * Chunking Strategy:
- * 1. First, split by sentence boundaries (punctuation: .!?;:)
+ * 1. First, split by sentence boundaries (multilingual punctuation)
  * 2. Merge sentences into chunks up to maxLength
  * 3. If a sentence exceeds maxLength:
  *    - For text with spaces: split by words
@@ -122,9 +144,8 @@ export function chunkText(
 		return [text];
 	}
 
-	// Step 1: Split by sentence boundaries (including various punctuation marks)
-	// Includes Western punctuation (.!?;:) and CJK punctuation (。！？；：)
-	const sentences = text.split(/([.!?;:。！？；：]+\s*)/);
+	// Step 1: Split by sentence boundaries (multilingual punctuation)
+	const sentences = text.split(SENTENCE_SPLIT_PATTERN);
 
 	const preliminaryChunks: string[] = [];
 	let currentChunk = "";

package/src/sdk/texttospeech.ts

@@ -21,9 +21,23 @@ import {
   detectAudioFormat,
   mergeMp3Binary,
   mergeWavBinary,
+  applyPronunciationDictionary,
+  type PronunciationDictionaryEntry,
   removeMp3Header,
   removeWavHeader,
 } from "../lib/custom_utils/index.js";
+
+type CreateSpeechOptions = RequestOptions & {
+  acceptHeaderOverride?: CreateSpeechAcceptEnum;
+  maxTextLength?: number;
+  pronunciationDictionary?: PronunciationDictionaryEntry[];
+};
+
+type StreamSpeechOptions = RequestOptions & {
+  acceptHeaderOverride?: StreamSpeechAcceptEnum;
+  maxTextLength?: number;
+  pronunciationDictionary?: PronunciationDictionaryEntry[];
+};
 // #endregion imports
 
 export { CreateSpeechAcceptEnum } from "../funcs/textToSpeechCreateSpeech.js";
@@ -53,11 +67,22 @@ export class TextToSpeech extends ClientSDK {
     return text.length > maxLength;
   }
 
+  /**
+   * Apply pronunciation dictionary before chunking (opt-in).
+   */
+  private applyPronunciationDictionary(
+    text: string,
+    pronunciationDictionary?: PronunciationDictionaryEntry[]
+  ): string {
+    if (!pronunciationDictionary) return text;
+    return applyPronunciationDictionary(text, pronunciationDictionary);
+  }
+
   /**
    * Extract audio data from response
    */
   private async extractAudioFromResponse(
-    response: operations.CreateSpeechResponse | operations.StreamSpeechResponse,
+    response: operations.CreateSpeechResponse | operations.StreamSpeechResponse
   ): Promise<Uint8Array> {
     const result = response.result;
 
@@ -74,9 +99,9 @@ export class TextToSpeech extends ClientSDK {
     }
 
     if (
-      typeof result === "object"
-      && result !== null
-      && "getReader" in result
+      typeof result === "object" &&
+      result !== null &&
+      "getReader" in result
     ) {
       // ReadableStream
       const reader = (result as ReadableStream<Uint8Array>).getReader();
@@ -131,14 +156,15 @@ export class TextToSpeech extends ClientSDK {
     // Enhanced error message with object inspection
     const resultType = typeof result;
     const resultConstructor = result?.constructor?.name || "unknown";
-    const resultKeys = result && typeof result === "object"
-      ? Object.keys(result).join(", ")
-      : "N/A";
+    const resultKeys =
+      result && typeof result === "object"
+        ? Object.keys(result).join(", ")
+        : "N/A";
 
     throw new Error(
-      `Unsupported result type: ${resultType}, `
-        + `constructor: ${resultConstructor}, `
-        + `keys: [${resultKeys}]`,
+      `Unsupported result type: ${resultType}, ` +
+        `constructor: ${resultConstructor}, ` +
+        `keys: [${resultKeys}]`
     );
   }
 
@@ -146,7 +172,7 @@ export class TextToSpeech extends ClientSDK {
    * Merge multiple audio responses into one
    */
   private async mergeAudioResponses(
-    responses: operations.CreateSpeechResponse[],
+    responses: operations.CreateSpeechResponse[]
   ): Promise<operations.CreateSpeechResponse> {
     if (responses.length === 0) {
       throw new Error("No responses to merge");
@@ -163,7 +189,7 @@ export class TextToSpeech extends ClientSDK {
 
     // Extract audio data from all responses
     const audioChunks: Uint8Array[] = await Promise.all(
-      responses.map((r) => this.extractAudioFromResponse(r)),
+      responses.map((r) => this.extractAudioFromResponse(r))
     );
 
     const firstChunk = audioChunks[0];
@@ -208,14 +234,14 @@ export class TextToSpeech extends ClientSDK {
     originalRequest: operations.StreamSpeechRequest,
     options?: RequestOptions & {
       acceptHeaderOverride?: StreamSpeechAcceptEnum;
-    },
+    }
   ): operations.StreamSpeechResponse {
     let audioFormat: "wav" | "mp3" | null = null;
     let isFirstAudioChunk = true;
 
     // Use arrow function to preserve 'this' context
     const processStream = async (
-      controller: ReadableStreamDefaultController<Uint8Array>,
+      controller: ReadableStreamDefaultController<Uint8Array>
     ) => {
       try {
         // Stream first response (first text chunk)
@@ -263,7 +289,7 @@ export class TextToSpeech extends ClientSDK {
           }
           const chunkResponse = await this._streamSpeechOriginal(
             chunkRequest,
-            options,
+            options
           );
 
           // Stream this text chunk's audio
@@ -323,40 +349,51 @@ export class TextToSpeech extends ClientSDK {
    */
   private async createSpeechWithChunking(
     request: operations.CreateSpeechRequest,
-    options?: RequestOptions & {
-      acceptHeaderOverride?: CreateSpeechAcceptEnum;
-      maxTextLength?: number;
-    },
+    options?: CreateSpeechOptions
   ): Promise<operations.CreateSpeechResponse> {
+    const { pronunciationDictionary, ...restOptions } = options ?? {};
     const maxLength = options?.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH;
-    const text = request.apiConvertTextToSpeechUsingCharacterRequest?.text
-      ?? "";
+    const text =
+      request.apiConvertTextToSpeechUsingCharacterRequest?.text ?? "";
+    const normalizedText = this.applyPronunciationDictionary(
+      text,
+      pronunciationDictionary
+    );
+
+    const baseRequest: operations.CreateSpeechRequest = {
+      ...request,
+      apiConvertTextToSpeechUsingCharacterRequest: {
+        ...request.apiConvertTextToSpeechUsingCharacterRequest,
+        text: normalizedText,
+      },
+    };
 
     // Short text: call original method directly
-    if (!this.shouldChunkText(text, maxLength)) {
+    if (!this.shouldChunkText(normalizedText, maxLength)) {
       if (!this._createSpeechOriginal) {
         throw new Error("Original createSpeech method not found");
       }
-      return this._createSpeechOriginal(request, options);
+      return this._createSpeechOriginal(baseRequest, restOptions);
     }
 
     // Long text: chunk, process sequentially (to avoid schema parsing issues), and merge
-    const textChunks = chunkText(text, maxLength);
+    const textChunks = chunkText(normalizedText, maxLength);
 
     // Determine Accept header based on output format
-    const outputFormat = request.apiConvertTextToSpeechUsingCharacterRequest
-      ?.outputFormat;
-    const acceptHeader: CreateSpeechAcceptEnum = outputFormat === "mp3"
-      ? CreateSpeechAcceptEnum.audioMpeg
-      : CreateSpeechAcceptEnum.audioWav;
+    const outputFormat =
+      baseRequest.apiConvertTextToSpeechUsingCharacterRequest?.outputFormat;
+    const acceptHeader: CreateSpeechAcceptEnum =
+      outputFormat === "mp3"
+        ? CreateSpeechAcceptEnum.audioMpeg
+        : CreateSpeechAcceptEnum.audioWav;
 
     // Process chunks sequentially to avoid race conditions in schema parsing
     const responses: operations.CreateSpeechResponse[] = [];
     for (const chunk of textChunks) {
       const chunkRequest: operations.CreateSpeechRequest = {
-        ...request,
+        ...baseRequest,
         apiConvertTextToSpeechUsingCharacterRequest: {
-          ...request.apiConvertTextToSpeechUsingCharacterRequest,
+          ...baseRequest.apiConvertTextToSpeechUsingCharacterRequest,
           text: chunk,
         },
       };
@@ -364,7 +401,7 @@ export class TextToSpeech extends ClientSDK {
         throw new Error("Original createSpeech method not found");
       }
       const response = await this._createSpeechOriginal(chunkRequest, {
-        ...options,
+        ...restOptions,
         acceptHeaderOverride: acceptHeader,
       });
       responses.push(response);
@@ -378,25 +415,35 @@ export class TextToSpeech extends ClientSDK {
    */
   private async streamSpeechWithChunking(
     request: operations.StreamSpeechRequest,
-    options?: RequestOptions & {
-      acceptHeaderOverride?: StreamSpeechAcceptEnum;
-      maxTextLength?: number;
-    },
+    options?: StreamSpeechOptions
   ): Promise<operations.StreamSpeechResponse> {
+    const { pronunciationDictionary, ...restOptions } = options ?? {};
     const maxLength = options?.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH;
-    const text = request.apiConvertTextToSpeechUsingCharacterRequest?.text
-      ?? "";
+    const text =
+      request.apiConvertTextToSpeechUsingCharacterRequest?.text ?? "";
+    const normalizedText = this.applyPronunciationDictionary(
+      text,
+      pronunciationDictionary
+    );
+
+    const baseRequest: operations.StreamSpeechRequest = {
+      ...request,
+      apiConvertTextToSpeechUsingCharacterRequest: {
+        ...request.apiConvertTextToSpeechUsingCharacterRequest,
+        text: normalizedText,
+      },
+    };
 
     // Short text: call original method directly
-    if (!this.shouldChunkText(text, maxLength)) {
+    if (!this.shouldChunkText(normalizedText, maxLength)) {
       if (!this._streamSpeechOriginal) {
         throw new Error("Original streamSpeech method not found");
       }
-      return this._streamSpeechOriginal(request, options);
+      return this._streamSpeechOriginal(baseRequest, restOptions);
     }
 
     // Long text: chunk and stream sequentially
-    const textChunks = chunkText(text, maxLength);
+    const textChunks = chunkText(normalizedText, maxLength);
 
     if (textChunks.length === 0) {
       throw new Error("No text chunks to process");
@@ -409,9 +456,9 @@ export class TextToSpeech extends ClientSDK {
 
     // Get first response to start streaming
     const firstChunkRequest: operations.StreamSpeechRequest = {
-      ...request,
+      ...baseRequest,
       apiConvertTextToSpeechUsingCharacterRequest: {
-        ...request.apiConvertTextToSpeechUsingCharacterRequest,
+        ...baseRequest.apiConvertTextToSpeechUsingCharacterRequest,
         text: firstChunk,
       },
     };
@@ -421,7 +468,7 @@ export class TextToSpeech extends ClientSDK {
     }
     const firstResponse = await this._streamSpeechOriginal(
       firstChunkRequest,
-      options,
+      restOptions
     );
 
     // Single chunk: return as-is
@@ -434,8 +481,8 @@ export class TextToSpeech extends ClientSDK {
     return this.createExtendedStreamingResponse(
       firstResponse,
       remainingChunks,
-      request,
-      options,
+      baseRequest,
+      restOptions
     );
   }
   // #endregion sdk-class-body
@@ -448,15 +495,9 @@ export class TextToSpeech extends ClientSDK {
    */
   async createSpeech(
     request: operations.CreateSpeechRequest,
-    options?: RequestOptions & {
-      acceptHeaderOverride?: CreateSpeechAcceptEnum;
-    },
+    options?: CreateSpeechOptions
   ): Promise<operations.CreateSpeechResponse> {
-    return unwrapAsync(textToSpeechCreateSpeech(
-      this,
-      request,
-      options,
-    ));
+    return unwrapAsync(textToSpeechCreateSpeech(this, request, options));
   }
 
   /**
@@ -467,15 +508,9 @@ export class TextToSpeech extends ClientSDK {
    */
   async streamSpeech(
     request: operations.StreamSpeechRequest,
-    options?: RequestOptions & {
-      acceptHeaderOverride?: StreamSpeechAcceptEnum;
-    },
+    options?: StreamSpeechOptions
   ): Promise<operations.StreamSpeechResponse> {
-    return unwrapAsync(textToSpeechStreamSpeech(
-      this,
-      request,
-      options,
-    ));
+    return unwrapAsync(textToSpeechStreamSpeech(this, request, options));
   }
 
   /**
@@ -486,12 +521,8 @@ export class TextToSpeech extends ClientSDK {
    */
   async predictDuration(
     request: operations.PredictDurationRequest,
-    options?: RequestOptions,
+    options?: RequestOptions
   ): Promise<operations.PredictDurationResponse> {
-    return unwrapAsync(textToSpeechPredictDuration(
-      this,
-      request,
-      options,
-    ));
+    return unwrapAsync(textToSpeechPredictDuration(this, request, options));
   }
 }