@deepgram/sdk 3.3.4 → 3.4.0

package/src/packages/PrerecordedClient.ts

@@ -1,162 +0,0 @@
-import { AbstractRestfulClient } from "./AbstractRestfulClient";
-import { CallbackUrl, appendSearchParams, isFileSource, isUrlSource } from "../lib/helpers";
-import { DeepgramError, isDeepgramError } from "../lib/errors";
-import type {
-  AsyncPrerecordedResponse,
-  DeepgramResponse,
-  Fetch,
-  FileSource,
-  PrerecordedSchema,
-  SyncPrerecordedResponse,
-  UrlSource,
-} from "../lib/types";
-
-export class PrerecordedClient extends AbstractRestfulClient {
-  async transcribeUrl(
-    source: UrlSource,
-    options?: PrerecordedSchema,
-    endpoint = "v1/listen"
-  ): Promise<DeepgramResponse<SyncPrerecordedResponse>> {
-    try {
-      let body;
-
-      if (isUrlSource(source)) {
-        body = JSON.stringify(source);
-      } else {
-        throw new DeepgramError("Unknown transcription source type");
-      }
-
-      if (options !== undefined && "callback" in options) {
-        throw new DeepgramError(
-          "Callback cannot be provided as an option to a synchronous transcription. Use `transcribeUrlCallback` or `transcribeFileCallback` instead."
-        );
-      }
-
-      const transcriptionOptions: PrerecordedSchema = { ...{}, ...options };
-
-      const url = new URL(endpoint, this.baseUrl);
-      appendSearchParams(url.searchParams, transcriptionOptions);
-
-      const result: SyncPrerecordedResponse = await this.post(this.fetch as Fetch, url, body);
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  async transcribeFile(
-    source: FileSource,
-    options?: PrerecordedSchema,
-    endpoint = "v1/listen"
-  ): Promise<DeepgramResponse<SyncPrerecordedResponse>> {
-    try {
-      let body;
-
-      if (isFileSource(source)) {
-        body = source;
-      } else {
-        throw new DeepgramError("Unknown transcription source type");
-      }
-
-      if (options !== undefined && "callback" in options) {
-        throw new DeepgramError(
-          "Callback cannot be provided as an option to a synchronous transcription. Use `transcribeUrlCallback` or `transcribeFileCallback` instead."
-        );
-      }
-
-      const transcriptionOptions: PrerecordedSchema = { ...{}, ...options };
-
-      const url = new URL(endpoint, this.baseUrl);
-      appendSearchParams(url.searchParams, transcriptionOptions);
-
-      const result: SyncPrerecordedResponse = await this.post(this.fetch as Fetch, url, body, {
-        "Content-Type": "deepgram/audio+video",
-      });
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  async transcribeUrlCallback(
-    source: UrlSource,
-    callback: CallbackUrl,
-    options?: PrerecordedSchema,
-    endpoint = "v1/listen"
-  ): Promise<DeepgramResponse<AsyncPrerecordedResponse>> {
-    try {
-      let body;
-
-      if (isUrlSource(source)) {
-        body = JSON.stringify(source);
-      } else {
-        throw new DeepgramError("Unknown transcription source type");
-      }
-
-      const transcriptionOptions: PrerecordedSchema = {
-        ...options,
-        ...{ callback: callback.toString() },
-      };
-
-      const url = new URL(endpoint, this.baseUrl);
-      appendSearchParams(url.searchParams, transcriptionOptions);
-
-      const result: AsyncPrerecordedResponse = await this.post(this.fetch as Fetch, url, body);
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  async transcribeFileCallback(
-    source: FileSource,
-    callback: CallbackUrl,
-    options?: PrerecordedSchema,
-    endpoint = "v1/listen"
-  ): Promise<DeepgramResponse<AsyncPrerecordedResponse>> {
-    try {
-      let body;
-
-      if (isFileSource(source)) {
-        body = source;
-      } else {
-        throw new DeepgramError("Unknown transcription source type");
-      }
-
-      const transcriptionOptions: PrerecordedSchema = {
-        ...options,
-        ...{ callback: callback.toString() },
-      };
-
-      const url = new URL(endpoint, this.baseUrl);
-      appendSearchParams(url.searchParams, transcriptionOptions);
-
-      const result: AsyncPrerecordedResponse = await this.post(this.fetch as Fetch, url, body, {
-        "Content-Type": "deepgram/audio+video",
-      });
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-}

package/src/packages/ReadClient.ts

@@ -1,161 +0,0 @@
-import { AbstractRestfulClient } from "./AbstractRestfulClient";
-import { CallbackUrl, appendSearchParams, isTextSource, isUrlSource } from "../lib/helpers";
-import { DeepgramError, isDeepgramError } from "../lib/errors";
-import type {
-  AnalyzeSchema,
-  AsyncAnalyzeResponse,
-  DeepgramResponse,
-  Fetch,
-  PrerecordedSchema,
-  SyncAnalyzeResponse,
-  TextSource,
-  UrlSource,
-} from "../lib/types";
-
-export class ReadClient extends AbstractRestfulClient {
-  async analyzeUrl(
-    source: UrlSource,
-    options?: AnalyzeSchema,
-    endpoint = "v1/read"
-  ): Promise<DeepgramResponse<SyncAnalyzeResponse>> {
-    try {
-      let body;
-
-      if (isUrlSource(source)) {
-        body = JSON.stringify(source);
-      } else {
-        throw new DeepgramError("Unknown source type");
-      }
-
-      if (options !== undefined && "callback" in options) {
-        throw new DeepgramError(
-          "Callback cannot be provided as an option to a synchronous transcription. Use `analyzeUrlCallback` or `analyzeTextCallback` instead."
-        );
-      }
-
-      const analyzeOptions: AnalyzeSchema = { ...{}, ...options };
-
-      const url = new URL(endpoint, this.baseUrl);
-      appendSearchParams(url.searchParams, analyzeOptions);
-
-      const result: SyncAnalyzeResponse = await this.post(this.fetch as Fetch, url, body);
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  async analyzeText(
-    source: TextSource,
-    options?: AnalyzeSchema,
-    endpoint = "v1/read"
-  ): Promise<DeepgramResponse<SyncAnalyzeResponse>> {
-    try {
-      let body;
-
-      if (isTextSource(source)) {
-        body = JSON.stringify(source);
-      } else {
-        throw new DeepgramError("Unknown source type");
-      }
-
-      if (options !== undefined && "callback" in options) {
-        throw new DeepgramError(
-          "Callback cannot be provided as an option to a synchronous requests. Use `analyzeUrlCallback` or `analyzeTextCallback` instead."
-        );
-      }
-
-      const analyzeOptions: AnalyzeSchema = { ...{}, ...options };
-
-      const url = new URL(endpoint, this.baseUrl);
-      appendSearchParams(url.searchParams, analyzeOptions);
-
-      const result: SyncAnalyzeResponse = await this.post(this.fetch as Fetch, url, body);
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  async analyzeUrlCallback(
-    source: UrlSource,
-    callback: CallbackUrl,
-    options?: AnalyzeSchema,
-    endpoint = "v1/read"
-  ): Promise<DeepgramResponse<AsyncAnalyzeResponse>> {
-    try {
-      let body;
-
-      if (isUrlSource(source)) {
-        body = JSON.stringify(source);
-      } else {
-        throw new DeepgramError("Unknown source type");
-      }
-
-      const transcriptionOptions: PrerecordedSchema = {
-        ...options,
-        ...{ callback: callback.toString() },
-      };
-
-      const url = new URL(endpoint, this.baseUrl);
-      appendSearchParams(url.searchParams, transcriptionOptions);
-
-      const result: AsyncAnalyzeResponse = await this.post(this.fetch as Fetch, url, body);
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  async analyzeTextCallback(
-    source: TextSource,
-    callback: CallbackUrl,
-    options?: AnalyzeSchema,
-    endpoint = "v1/read"
-  ): Promise<DeepgramResponse<AsyncAnalyzeResponse>> {
-    try {
-      let body;
-
-      if (isTextSource(source)) {
-        body = JSON.stringify(source);
-      } else {
-        throw new DeepgramError("Unknown source type");
-      }
-
-      const transcriptionOptions: PrerecordedSchema = {
-        ...options,
-        ...{ callback: callback.toString() },
-      };
-
-      const url = new URL(endpoint, this.baseUrl);
-      appendSearchParams(url.searchParams, transcriptionOptions);
-
-      const result: AsyncAnalyzeResponse = await this.post(this.fetch as Fetch, url, body, {
-        "Content-Type": "deepgram/audio+video",
-      });
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-}

package/src/packages/SpeakClient.ts

@@ -1,50 +0,0 @@
-import { AbstractRestfulClient } from "./AbstractRestfulClient";
-import { DeepgramError, DeepgramUnknownError, isDeepgramError } from "../lib/errors";
-import { appendSearchParams, isTextSource } from "../lib/helpers";
-import { Fetch, SpeakSchema, TextSource } from "../lib/types";
-
-export class SpeakClient extends AbstractRestfulClient {
-  public result: undefined | Response;
-
-  /**
-   * @see https://developers.deepgram.com/reference/text-to-speech-api
-   */
-  async request(
-    source: TextSource,
-    options?: SpeakSchema,
-    endpoint = "v1/speak"
-  ): Promise<SpeakClient> {
-    try {
-      let body;
-
-      if (isTextSource(source)) {
-        body = JSON.stringify(source);
-      } else {
-        throw new DeepgramError("Unknown transcription source type");
-      }
-
-      const speakOptions: SpeakSchema = { ...{ model: "aura-asteria-en" }, ...options };
-
-      const url = new URL(endpoint, this.baseUrl);
-      appendSearchParams(url.searchParams, speakOptions);
-      this.result = await this._handleRawRequest(this.fetch as Fetch, "POST", url, {}, {}, body);
-      return this;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async getStream(): Promise<ReadableStream<Uint8Array> | null> {
-    if (!this.result)
-      throw new DeepgramUnknownError("Tried to get stream before making request", "");
-
-    return this.result.body;
-  }
-
-  async getHeaders(): Promise<Headers> {
-    if (!this.result)
-      throw new DeepgramUnknownError("Tried to get headers before making request", "");
-
-    return this.result.headers;
-  }
-}