@deepgram/sdk 4.11.1 → 5.0.0-alpha.1

package/src/packages/ModelsRestClient.ts

@@ -1,93 +0,0 @@
-import { isDeepgramError } from "../lib/errors";
-import {
-  DeepgramResponse,
-  GetModelResponse,
-  GetModelsResponse,
-  GetModelsSchema,
-} from "../lib/types";
-import { AbstractRestClient } from "./AbstractRestClient";
-
-/**
- * Represents a REST client for interacting with the Deepgram API.
- *
- * The `ModelsRestClient` class provides methods for interacting with the Deepgram API to retrieve information about available models.
- * @extends AbstractRestClient
- */
-export class ModelsRestClient extends AbstractRestClient {
-  public namespace: string = "models";
-
-  /**
-   * Retrieves a list of all available models.
-   *
-   * @param endpoint - (optional) The endpoint to request.
-   * @returns A promise that resolves with the response from the Deepgram API.
-   * @example
-   * ```typescript
-   * import { createClient } from "@deepgram/sdk";
-   *
-   * const deepgram = createClient(DEEPGRAM_API_KEY);
-   * const { result: models, error } = deepgram.models.getAll();
-   *
-   * if (error) {
-   *   console.error(error);
-   * } else {
-   *   console.log(models);
-   * }
-   * ```
-   */
-  async getAll(
-    endpoint = ":version/models",
-    options: GetModelsSchema = {}
-  ): Promise<DeepgramResponse<GetModelsResponse>> {
-    try {
-      const requestUrl = this.getRequestUrl(endpoint, {}, options);
-      const result: GetModelsResponse = await this.get(requestUrl).then((result) => result.json());
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  /**
-   * Retrieves information about a specific model.
-   *
-   * @param modelId - The UUID of the model to retrieve.
-   * @param endpoint - (optional) The endpoint to request.
-   * @returns A promise that resolves with the response from the Deepgram API.
-   * @example
-   * ```typescript
-   * import { createClient } from "@deepgram/sdk";
-   *
-   * const deepgram = createClient(DEEPGRAM_API_KEY);
-   * const { result: model, error } = deepgram.models.getModel("modelId");
-   *
-   * if (error) {
-   *   console.error(error);
-   * } else {
-   *   console.log(model);
-   * }
-   * ```
-   */
-  async getModel(
-    modelId: string,
-    endpoint = ":version/models/:modelId"
-  ): Promise<DeepgramResponse<GetModelResponse>> {
-    try {
-      const requestUrl = this.getRequestUrl(endpoint, { modelId });
-      const result: GetModelResponse = await this.get(requestUrl).then((result) => result.json());
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-}

package/src/packages/ReadRestClient.ts

@@ -1,200 +0,0 @@
-import { CallbackUrl, isTextSource, isUrlSource } from "../lib/helpers";
-import { DeepgramError, isDeepgramError } from "../lib/errors";
-import type {
-  AnalyzeSchema,
-  AsyncAnalyzeResponse,
-  DeepgramResponse,
-  SyncAnalyzeResponse,
-  TextSource,
-  UrlSource,
-} from "../lib/types";
-import { AbstractRestClient } from "./AbstractRestClient";
-
-/**
- * The `ReadRestClient` class extends the `AbstractRestClient` class and provides methods for analyzing audio sources synchronously and asynchronously.
- *
- * The `analyzeUrl` method analyzes a URL-based audio source synchronously, returning a promise that resolves to the analysis response or an error.
- *
- * The `analyzeText` method analyzes a text-based audio source synchronously, returning a promise that resolves to the analysis response or an error.
- *
- * The `analyzeUrlCallback` method analyzes a URL-based audio source asynchronously, returning a promise that resolves to the analysis response or an error.
- *
- * The `analyzeTextCallback` method analyzes a text-based audio source asynchronously, returning a promise that resolves to the analysis response or an error.
- */
-export class ReadRestClient extends AbstractRestClient {
-  public namespace: string = "read";
-
-  /**
-   * Analyzes a URL-based audio source synchronously.
-   *
-   * @param source - The URL-based audio source to analyze.
-   * @param options - Optional analysis options.
-   * @param endpoint - The API endpoint to use for the analysis. Defaults to ":version/read".
-   * @returns A promise that resolves to the analysis response, or an error if the analysis fails.
-   */
-  async analyzeUrl(
-    source: UrlSource,
-    options?: AnalyzeSchema,
-    endpoint = ":version/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 requestUrl = this.getRequestUrl(endpoint, {}, { ...{}, ...options });
-      const result: SyncAnalyzeResponse = await this.post(requestUrl, body).then((result) =>
-        result.json()
-      );
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  /**
-   * Analyzes a text-based audio source synchronously.
-   *
-   * @param source - The text-based audio source to analyze.
-   * @param options - Optional analysis options.
-   * @param endpoint - The API endpoint to use for the analysis. Defaults to ":version/read".
-   * @returns A promise that resolves to the analysis response, or an error if the analysis fails.
-   */
-  async analyzeText(
-    source: TextSource,
-    options?: AnalyzeSchema,
-    endpoint = ":version/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 requestUrl = this.getRequestUrl(endpoint, {}, { ...{}, ...options });
-      const result: SyncAnalyzeResponse = await this.post(requestUrl, body).then((result) =>
-        result.json()
-      );
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  /**
-   * Analyzes a URL-based audio source asynchronously.
-   *
-   * @param source - The URL-based audio source to analyze.
-   * @param callback - The URL to call back with the analysis results.
-   * @param options - Optional analysis options.
-   * @param endpoint - The API endpoint to use for the analysis. Defaults to ":version/read".
-   * @returns A promise that resolves to the analysis response, or an error if the analysis fails.
-   */
-  async analyzeUrlCallback(
-    source: UrlSource,
-    callback: CallbackUrl,
-    options?: AnalyzeSchema,
-    endpoint = ":version/read"
-  ): Promise<DeepgramResponse<AsyncAnalyzeResponse>> {
-    try {
-      let body;
-
-      if (isUrlSource(source)) {
-        body = JSON.stringify(source);
-      } else {
-        throw new DeepgramError("Unknown source type");
-      }
-
-      const requestUrl = this.getRequestUrl(
-        endpoint,
-        {},
-        { ...options, callback: callback.toString() }
-      );
-      const result: AsyncAnalyzeResponse = await this.post(requestUrl, body).then((result) =>
-        result.json()
-      );
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  /**
-   * Analyzes a text-based audio source asynchronously.
-   *
-   * @param source - The text-based audio source to analyze.
-   * @param callback - The URL to call back with the analysis results.
-   * @param options - Optional analysis options.
-   * @param endpoint - The API endpoint to use for the analysis. Defaults to ":version/read".
-   * @returns A promise that resolves to the analysis response, or an error if the analysis fails.
-   */
-  async analyzeTextCallback(
-    source: TextSource,
-    callback: CallbackUrl,
-    options?: AnalyzeSchema,
-    endpoint = ":version/read"
-  ): Promise<DeepgramResponse<AsyncAnalyzeResponse>> {
-    try {
-      let body;
-
-      if (isTextSource(source)) {
-        body = JSON.stringify(source);
-      } else {
-        throw new DeepgramError("Unknown source type");
-      }
-
-      const requestUrl = this.getRequestUrl(
-        endpoint,
-        {},
-        { ...options, callback: callback.toString() }
-      );
-      const result: AsyncAnalyzeResponse = await this.post(requestUrl, body, {
-        headers: { "Content-Type": "deepgram/audio+video" },
-      }).then((result) => result.json());
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-}
-
-export { ReadRestClient as ReadClient };

package/src/packages/SelfHostedRestClient.ts

@@ -1,134 +0,0 @@
-import { isDeepgramError } from "../lib/errors";
-import type {
-  CreateOnPremCredentialsSchema,
-  DeepgramResponse,
-  ListOnPremCredentialsResponse,
-  MessageResponse,
-  OnPremCredentialResponse,
-} from "../lib/types";
-import { AbstractRestClient } from "./AbstractRestClient";
-
-/**
- * The `SelfHostedRestClient` class extends the `AbstractRestClient` class and provides methods for interacting with the Deepgram self-hosted API.
- *
- * This class is used to list, retrieve, create, and delete self-hosted credentials for a Deepgram project.
- */
-export class SelfHostedRestClient extends AbstractRestClient {
-  public namespace: string = "selfhosted";
-
-  /**
-   * Lists the self-hosted credentials for a Deepgram project.
-   *
-   * @param projectId - The ID of the Deepgram project.
-   * @returns A promise that resolves to an object containing the list of self-hosted credentials and any error that occurred.
-   * @see https://developers.deepgram.com/reference/list-credentials
-   */
-  async listCredentials(
-    projectId: string,
-    endpoint = ":version/projects/:projectId/onprem/distribution/credentials"
-  ): Promise<DeepgramResponse<ListOnPremCredentialsResponse>> {
-    try {
-      const requestUrl = this.getRequestUrl(endpoint, { projectId });
-      const result: ListOnPremCredentialsResponse = await this.get(requestUrl).then((result) =>
-        result.json()
-      );
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  /**
-   * Retrieves the self-hosted credentials for a specific Deepgram project and credentials ID.
-   *
-   * @param projectId - The ID of the Deepgram project.
-   * @param credentialsId - The ID of the self-hosted credentials to retrieve.
-   * @returns A promise that resolves to an object containing the self-hosted credentials and any error that occurred.
-   * @see https://developers.deepgram.com/reference/get-credentials
-   */
-  async getCredentials(
-    projectId: string,
-    credentialsId: string,
-    endpoint = ":version/projects/:projectId/onprem/distribution/credentials/:credentialsId"
-  ): Promise<DeepgramResponse<OnPremCredentialResponse>> {
-    try {
-      const requestUrl = this.getRequestUrl(endpoint, { projectId, credentialsId });
-      const result: OnPremCredentialResponse = await this.get(requestUrl).then((result) =>
-        result.json()
-      );
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  /**
-   * Creates self-hosted credentials for a specific Deepgram project.
-   *
-   * @param projectId - The ID of the Deepgram project.
-   * @param options - The options for creating the self-hosted credentials.
-   * @returns A promise that resolves to an object containing the created self-hosted credentials and any error that occurred.
-   * @see https://developers.deepgram.com/reference/create-credentials
-   */
-  async createCredentials(
-    projectId: string,
-    options: CreateOnPremCredentialsSchema,
-    endpoint = ":version/projects/:projectId/onprem/distribution/credentials"
-  ): Promise<DeepgramResponse<OnPremCredentialResponse>> {
-    try {
-      const requestUrl = this.getRequestUrl(endpoint, { projectId });
-      const body = JSON.stringify(options);
-
-      const result: OnPremCredentialResponse = await this.post(requestUrl, body).then((result) =>
-        result.json()
-      );
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-
-  /**
-   * Deletes self-hosted credentials for a specific Deepgram project.
-   *
-   * @param projectId - The ID of the Deepgram project.
-   * @param credentialsId - The ID of the self-hosted credentials to delete.
-   * @returns A promise that resolves to an object containing a message response and any error that occurred.
-   * @see https://developers.deepgram.com/reference/delete-credentials
-   */
-  async deleteCredentials(
-    projectId: string,
-    credentialsId: string,
-    endpoint = ":version/projects/:projectId/onprem/distribution/credentials/:credentialsId"
-  ): Promise<DeepgramResponse<MessageResponse>> {
-    try {
-      const requestUrl = this.getRequestUrl(endpoint, { projectId, credentialsId });
-      const result: MessageResponse = await this.delete(requestUrl).then((result) => result.json());
-
-      return { result, error: null };
-    } catch (error) {
-      if (isDeepgramError(error)) {
-        return { result: null, error };
-      }
-
-      throw error;
-    }
-  }
-}
-
-export { SelfHostedRestClient as OnPremClient };

package/src/packages/SpeakClient.ts

@@ -1,35 +0,0 @@
-import { AbstractClient } from "./AbstractClient";
-import { SpeakLiveClient } from "./SpeakLiveClient";
-import { SpeakRestClient } from "./SpeakRestClient";
-import { SpeakSchema } from "../lib/types";
-import { TextSource } from "../lib/types";
-
-/**
- * The `SpeakClient` class extends the `AbstractClient` class and provides access to the "speak" namespace.
- * It exposes two methods:
- *
- * 1. `request()`: Returns a `SpeakRestClient` instance for interacting with the rest speak API.
- * 2. `live(ttsOptions: SpeakSchema = {}, endpoint = ":version/speak")`: Returns a `SpeakLiveClient` instance for interacting with the live speak API, with the provided TTS options and endpoint.
- */
-export class SpeakClient extends AbstractClient {
-  public namespace: string = "speak";
-
-  /**
-   * Returns a `SpeakRestClient` instance for interacting with the rest speak API.
-   */
-  public request(source: TextSource, options?: SpeakSchema, endpoint = ":version/speak") {
-    const client = new SpeakRestClient(this.options);
-
-    return client.request(source, options, endpoint);
-  }
-
-  /**
-   * Returns a `SpeakLiveClient` instance for interacting with the live speak API, with the provided TTS options and endpoint.
-   * @param {SpeakSchema} [ttsOptions={}] - The TTS options to use for the live speak API.
-   * @param {string} [endpoint=":version/speak"] - The endpoint to use for the live speak API.
-   * @returns {SpeakLiveClient} - A `SpeakLiveClient` instance for interacting with the live speak API.
-   */
-  public live(ttsOptions: SpeakSchema = {}, endpoint: string = ":version/speak"): SpeakLiveClient {
-    return new SpeakLiveClient(this.options, ttsOptions, endpoint);
-  }
-}

package/src/packages/SpeakLiveClient.ts

@@ -1,171 +0,0 @@
-import { AbstractLiveClient } from "./AbstractLiveClient";
-import { LiveTTSEvents } from "../lib/enums";
-import type { SpeakSchema, DeepgramClientOptions } from "../lib/types";
-
-/**
- * The `SpeakLiveClient` class extends the `AbstractLiveClient` class and provides functionality for setting up and managing a WebSocket connection for live text-to-speech synthesis.
- *
- * The constructor takes in `DeepgramClientOptions` and an optional `SpeakSchema` object, as well as an optional `endpoint` string. It then calls the `connect` method of the parent `AbstractLiveClient` class to establish the WebSocket connection.
- *
- * The `setupConnection` method is responsible for handling the various events that can occur on the WebSocket connection, such as opening, closing, and receiving messages. It sets up event handlers for these events and emits the appropriate events based on the message type.
- *
- * The `configure` method allows you to send additional configuration options to the connected session.
- *
- * The `requestClose` method requests the server to close the connection.
- */
-export class SpeakLiveClient extends AbstractLiveClient {
-  public namespace: string = "speak";
-
-  /**
-   * Constructs a new `SpeakLiveClient` instance with the provided options.
-   *
-   * @param options - The `DeepgramClientOptions` to use for the client connection.
-   * @param speakOptions - An optional `SpeakSchema` object containing additional configuration options for the text-to-speech.
-   * @param endpoint - An optional string representing the WebSocket endpoint to connect to. Defaults to `:version/speak`.
-   */
-  constructor(
-    options: DeepgramClientOptions,
-    speakOptions: Omit<SpeakSchema, "container"> = {},
-    endpoint: string = ":version/speak"
-  ) {
-    super(options);
-
-    this.connect(speakOptions, endpoint);
-  }
-
-  /**
-   * Sets up the connection event handlers.
-   * This method is responsible for handling the various events that can occur on the WebSocket connection, such as opening, closing, and receiving data.
-   * - When the connection is opened, it emits the `LiveTTSEvents.Open` event.
-   * - When the connection is closed, it emits the `LiveTTSEvents.Close` event.
-   * - When an error occurs on the connection, it emits the `LiveTTSEvents.Error` event.
-   * - When a message is received, it parses the message and emits the appropriate event based on the message type, such as `LiveTTSEvents.Metadata`, `LiveTTSEvents.Flushed`, and `LiveTTSEvents.Warning`.
-   */
-  public setupConnection(): void {
-    // Set up standard connection events (open, close, error) using abstracted method
-    this.setupConnectionEvents({
-      Open: LiveTTSEvents.Open,
-      Close: LiveTTSEvents.Close,
-      Error: LiveTTSEvents.Error,
-    });
-
-    // Set up message handling specific to text-to-speech
-    if (this.conn) {
-      this.conn.onmessage = (event: MessageEvent) => {
-        this.handleMessage(event);
-      };
-    }
-  }
-
-  /**
-   * Handles text messages received from the WebSocket connection.
-   * @param data - The parsed JSON data.
-   */
-  protected handleTextMessage(data: any): void {
-    if (data.type === LiveTTSEvents.Metadata) {
-      this.emit(LiveTTSEvents.Metadata, data);
-    } else if (data.type === LiveTTSEvents.Flushed) {
-      this.emit(LiveTTSEvents.Flushed, data);
-    } else if (data.type === LiveTTSEvents.Warning) {
-      this.emit(LiveTTSEvents.Warning, data);
-    } else {
-      this.emit(LiveTTSEvents.Unhandled, data);
-    }
-  }
-
-  /**
-   * Handles binary messages received from the WebSocket connection.
-   * @param data - The binary data.
-   */
-  protected handleBinaryMessage(data: Buffer): void {
-    this.emit(LiveTTSEvents.Audio, data);
-  }
-
-  /**
-   * Sends a text input message to the server.
-   *
-   * @param {string} text - The text to convert to speech.
-   */
-  public sendText(text: string): void {
-    this.send(
-      JSON.stringify({
-        type: "Speak",
-        text,
-      })
-    );
-  }
-
-  /**
-   * Requests the server flush the current buffer and return generated audio.
-   */
-  public flush(): void {
-    this.send(
-      JSON.stringify({
-        type: "Flush",
-      })
-    );
-  }
-
-  /**
-   * Requests the server clear the current buffer.
-   */
-  public clear(): void {
-    this.send(
-      JSON.stringify({
-        type: "Clear",
-      })
-    );
-  }
-
-  /**
-   * Requests the server close the connection.
-   */
-  public requestClose(): void {
-    this.send(
-      JSON.stringify({
-        type: "Close",
-      })
-    );
-  }
-
-  /**
-   * Handles incoming messages from the WebSocket connection.
-   * @param event - The MessageEvent object representing the received message.
-   */
-  protected handleMessage(event: MessageEvent): void {
-    if (typeof event.data === "string") {
-      try {
-        const data = JSON.parse(event.data);
-        this.handleTextMessage(data);
-      } catch (error) {
-        this.emit(LiveTTSEvents.Error, {
-          event,
-          message: "Unable to parse `data` as JSON.",
-          error,
-          url: this.conn?.url,
-          readyState: this.conn?.readyState,
-          data:
-            event.data?.toString().substring(0, 200) +
-            (event.data?.toString().length > 200 ? "..." : ""),
-        });
-      }
-    } else if (event.data instanceof Blob) {
-      event.data.arrayBuffer().then((buffer) => {
-        this.handleBinaryMessage(Buffer.from(buffer));
-      });
-    } else if (event.data instanceof ArrayBuffer) {
-      this.handleBinaryMessage(Buffer.from(event.data));
-    } else if (Buffer.isBuffer(event.data)) {
-      this.handleBinaryMessage(event.data);
-    } else {
-      console.log("Received unknown data type", event.data);
-      this.emit(LiveTTSEvents.Error, {
-        event,
-        message: "Received unknown data type.",
-        url: this.conn?.url,
-        readyState: this.conn?.readyState,
-        dataType: typeof event.data,
-      });
-    }
-  }
-}