@d-id/client-sdk 2.0.10 → 3.0.0-staging.413

package/dist/src/errors/http-error.d.ts

@@ -1,12 +1,74 @@
 import { BaseError, ErrorJson } from './base-error';
+import { RequestMeta } from './request-meta';
 
+/**
+ * A request to the Agents API came back with a non-2xx status.
+ *
+ * Raised for every REST call the SDK makes on the application's behalf: fetching the agent in
+ * {@link createAgentManager}, creating the stream and the chat during
+ * {@link AgentManager.connect | connect()}, sending a message with
+ * {@link AgentManager.chat | chat()}, and the rating and feedback calls. The same error is both
+ * handed to {@link AgentManagerCallbacks.onError | onError} and thrown, so it also rejects the
+ * promise of whichever method made the request — catch it around that call, or handle it centrally
+ * in the callback. For the message-send request behind {@link AgentManager.chat | chat()} the
+ * callback may not fire; the error is still thrown. Typical cases are `401` or `403` for a client
+ * key that is not authorized for the agent or the calling domain, and `404` for an unknown agent
+ * id; an account that is out of credits comes back with {@link BaseError.kind | kind}
+ * `'InsufficientCreditsError'`. A `429` is retried twice, one second apart (three attempts in
+ * total), before it surfaces.
+ *
+ * {@link BaseError.kind | kind} is the server's own classification when the response body is D-ID's
+ * `{ kind, description }` envelope — the `'InsufficientCreditsError'` above is one — and
+ * `'HttpError'` otherwise, so a message-independent branch on a specific API failure is possible.
+ *
+ * The message is the envelope's `description` when the body is that JSON, and the raw body
+ * otherwise — truncated to 256 characters either way, because a gateway can answer a 5xx with a
+ * whole HTML page.
+ *
+ * @category Errors
+ */
 export declare class HttpError extends BaseError {
+    /**
+     * The server's own classification of the failure, and `'HttpError'` when the response body was
+     * not D-ID's `{ kind, description }` envelope.
+     *
+     * The only {@link BaseError.kind | kind} in the SDK that is not a fixed literal, so it stays
+     * typed `string`: an account out of credits comes back as `'InsufficientCreditsError'`, for
+     * instance. Use {@link HttpError.status | status} for the transport-level branch and this for
+     * the API-level one.
+     */
+    readonly kind: string;
+    /**
+     * HTTP status code of the response, such as `401`, `404` or `500`.
+     */
     readonly status: number;
-    readonly url?: string;
+    /**
+     * Path of the request that failed, relative to the API client's base path — for example
+     * `/agt_x/chat/cht_y` for a message sent to a chat.
+     *
+     * Absent when the error was constructed without call context. {@link NetworkError.endpoint}
+     * is the same value on a transport failure.
+     */
+    readonly endpoint?: string;
+    /**
+     * HTTP method of the request that failed, such as `GET` or `POST`.
+     *
+     * Absent when the error was constructed without call context.
+     */
     readonly method?: string;
-    constructor(status: number, body: string, meta?: {
-        url?: string;
-        method?: string;
-    });
+    /**
+     * Builds the error from the failing response.
+     * @internal The SDK builds this itself; applications catch the error rather than construct it.
+     */
+    constructor(status: number, body: string, meta?: RequestMeta);
+    /**
+     * Serializes the error, adding the failing call to what
+     * {@link BaseError.toJson | BaseError.toJson()} already returns.
+     *
+     * Adds `httpStatus` from {@link HttpError.status | status}, and `endpoint` and `method` when the
+     * call context is known. The raw `status` property is serialized as `httpStatus`.
+     *
+     * @returns The error as plain, JSON-serializable data.
+     */
     toJson(): ErrorJson;
 }

package/dist/src/errors/index.d.ts

@@ -3,6 +3,7 @@ export * from './chat/chat-creation-failed';
 export * from './chat/chat-mode-downgraded';
 export * from './http-error';
 export * from './network-error';
+export * from './request-meta';
 export * from './stream-error';
 export * from './validation-error';
 export * from './ws-error';

package/dist/src/errors/network-error.d.ts

@@ -1,18 +1,72 @@
 import { BaseError, ErrorJson } from './base-error';
+import { RequestMeta } from './request-meta';
 
-export interface NetworkErrorMeta {
-    url?: string;
-    method?: string;
-    durationMs?: number;
-    online?: boolean;
-    visibility?: DocumentVisibilityState;
-}
+/**
+ * A request to the Agents API never reached the server, so no response came back.
+ *
+ * This is the transport failure counterpart of {@link HttpError}, where the server did answer: the
+ * browser's `fetch` rejected outright because the device is offline, DNS or TLS failed, the
+ * connection was refused or the request was blocked, for instance by CORS or an extension. Like
+ * {@link HttpError} it is both handed to {@link AgentManagerCallbacks.onError | onError} and
+ * thrown, so it also rejects the promise of the method that made the request; for the message-send
+ * request behind {@link AgentManager.chat | chat()} the callback may not fire, but the error is
+ * still thrown. A request the SDK cancelled itself is not reported this way — the browser's own
+ * `AbortError` is rethrown unchanged.
+ *
+ * The message is always `'Network request failed'`; the browser's own wording, such as
+ * `'Failed to fetch'`, is kept in {@link BaseError.originalError | originalError} and appears as
+ * `cause` in {@link NetworkError.toJson | toJson()}. The remaining properties record what was
+ * happening at the time, which is usually what distinguishes a dropped connection from a tab that
+ * was backgrounded.
+ *
+ * @category Errors
+ */
 export declare class NetworkError extends BaseError {
+    /**
+     * Always `'NetworkError'`. Branch on it to tell this failure from the other SDK errors.
+     */
+    readonly kind: 'NetworkError';
+    /**
+     * Path of the request that failed, relative to the API client's base path — for example
+     * `/agt_x/chat/cht_y`.
+     */
     readonly endpoint?: string;
+    /**
+     * HTTP method of the request that failed, such as `GET` or `POST`.
+     */
     readonly method?: string;
+    /**
+     * How long the request ran before it failed, in milliseconds.
+     *
+     * A value close to zero usually means the request never left the browser; a large one points
+     * at a connection that was established and then lost.
+     */
     readonly durationMs?: number;
+    /**
+     * The browser's `navigator.onLine` at the moment of the failure — `false` when the device
+     * reported itself offline.
+     */
     readonly online?: boolean;
+    /**
+     * The page's `document.visibilityState` at the moment of the failure.
+     *
+     * `'hidden'` means the tab was in the background, where browsers throttle or suspend network
+     * activity.
+     */
     readonly visibility?: DocumentVisibilityState;
-    constructor(originalError?: unknown, meta?: NetworkErrorMeta);
+    /**
+     * Wraps a rejected `fetch` together with what was known about the call.
+     * @internal The SDK builds this itself; applications catch the error rather than construct it.
+     */
+    constructor(originalError?: unknown, meta?: RequestMeta);
+    /**
+     * Serializes the error, adding the captured context to what
+     * {@link BaseError.toJson | BaseError.toJson()} already returns.
+     *
+     * Each of `endpoint`, `method`, `durationMs`, `online` and `visibility` is included only when it
+     * was captured.
+     *
+     * @returns The error as plain, JSON-serializable data.
+     */
     toJson(): ErrorJson;
 }

package/dist/src/errors/request-meta.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Request context recorded on an error: what was requested, how long it took and what the tab
+ * could see of the network at the time. Shared by `HttpError` and `NetworkError`.
+ * @internal Implementation type; not part of the public SDK surface.
+ */
+export interface RequestMeta {
+    endpoint?: string;
+    method?: string;
+    durationMs?: number;
+    online?: boolean;
+    visibility?: DocumentVisibilityState;
+}

package/dist/src/errors/stream-error.d.ts

@@ -1,5 +1,37 @@
 import { BaseError } from './base-error';
 
+/**
+ * Something went wrong inside the live audio and video stream.
+ *
+ * Unlike {@link HttpError} and {@link NetworkError}, which come from REST calls, this one comes
+ * from the transport carrying the agent's video, so it is only ever delivered to
+ * {@link AgentManagerCallbacks.onError | onError} — no call of yours is necessarily in flight when
+ * it happens, and nothing throws it. The SDK raises it when:
+ *
+ * - no media track is subscribed within the timeout after the LiveKit room used by Expressive (V4)
+ *   agents connects, after which the SDK disconnects the stream;
+ * - the LiveKit room reports a media-device or encryption failure;
+ * - a message cannot be put on the data channel — the WebRTC channel used by Talks (V2) and Clips
+ *   (V3) is not open, or the LiveKit room is not connected or rejects the send;
+ * - the server reports that the stream itself failed, with the message
+ *   `Stream failed with event <event>`.
+ *
+ * Most of these leave the session unusable, so the useful response is to tell the user and call
+ * {@link AgentManager.reconnect | reconnect()}. {@link BaseError.kind | kind} is `'StreamError'`.
+ * The message describes the failure, and is the plain `'Stream Error'` when the transport gave no
+ * detail; the underlying error, where there was one, is kept as
+ * {@link BaseError.originalError | originalError}.
+ *
+ * @category Errors
+ */
 export declare class StreamError extends BaseError {
+    /**
+     * Always `'StreamError'`. Branch on it to tell this failure from the other SDK errors.
+     */
+    readonly kind: 'StreamError';
+    /**
+     * Wraps a streaming failure.
+     * @internal The SDK builds this itself; applications catch the error rather than construct it.
+     */
     constructor(message: string, originalError?: unknown);
 }

package/dist/src/errors/validation-error.d.ts

@@ -1,6 +1,67 @@
 import { BaseError } from './base-error';
 
+/**
+ * A method was called with arguments, or in a state, that the SDK will not send to the Agents
+ * API.
+ *
+ * This is one of the two SDK errors that only ever reach the caller and are never delivered to
+ * {@link AgentManagerCallbacks.onError | onError} (the other is {@link ChatCreationFailed}): it is
+ * the direct answer to the call you just made, and every method that raises it rejects the promise
+ * it returned, so `await` the call inside a `try`/`catch` or attach a `.catch()`. The SDK raises it
+ * from
+ * {@link AgentManager.chat | chat()} when the message is empty or 2000 characters or longer, when
+ * the session's {@link ChatMode} has chat disabled or is in maintenance, and when the chat or the
+ * stream has not been initialized yet; from {@link AgentManager.speak | speak()} when it is called
+ * before {@link AgentManager.connect | connect()}; and from
+ * {@link AgentManager.rate | rate()}, {@link AgentManager.deleteRate | deleteRate()} and
+ * {@link AgentManager.submitFeedback | submitFeedback()} when no chat has started, plus, for
+ * `rate()` alone, when no message with the given id is in the transcript. It is also raised from
+ * {@link createAgentManager} and {@link AgentManager.changeMode | changeMode()} when an Expressive
+ * (V4) agent is asked for {@link ChatMode.Off} or {@link ChatMode.DirectPlayback}, which only Talks
+ * (V2) and Clips (V3) agents support. The five Expressive-only media methods —
+ * {@link AgentManager.publishMicrophoneStream | publishMicrophoneStream()},
+ * {@link AgentManager.replaceMicrophoneTrack | replaceMicrophoneTrack()},
+ * {@link AgentManager.publishCameraStream | publishCameraStream()},
+ * {@link AgentManager.setSttLanguage | setSttLanguage()} and
+ * {@link AgentManager.sendDataChannelMessage | sendDataChannelMessage()} — raise it the other way
+ * round: when the session is a Talks (V2) or Clips (V3) one, or
+ * {@link AgentManager.connect | connect()} has not run yet.
+ *
+ * Nothing was sent to the Agents API when this is raised, so the session stays usable: fix the
+ * argument or wait for {@link ConnectionState.Connected | 'connected'} and call again.
+ * {@link BaseError.kind | kind} is `'ValidationError'`.
+ *
+ * @category Errors
+ */
 export declare class ValidationError extends BaseError {
+    /**
+     * Name of the field the failure is about.
+     *
+     * The SDK does not populate it — every validation it raises passes the message alone — so it
+     * is only set on a `ValidationError` an application constructed itself. It is also left out
+     * of {@link BaseError.toJson | toJson()}, so a serialized validation error carries only its
+     * kind and message.
+     */
     readonly key?: string | undefined;
-    constructor(message: string, key?: string | undefined);
+    /**
+     * Always `'ValidationError'`. Branch on it to tell this failure from the other SDK errors.
+     */
+    readonly kind: 'ValidationError';
+    /**
+     * Builds a validation failure. The SDK does this itself before it performs a request.
+     *
+     * @param message - What was wrong with the call, such as `'Message cannot be empty'`.
+     * @param key - Name of the field the failure is about. The SDK's own validations leave it
+     * unset.
+     */
+    constructor(message: string, 
+    /**
+     * Name of the field the failure is about.
+     *
+     * The SDK does not populate it — every validation it raises passes the message alone — so it
+     * is only set on a `ValidationError` an application constructed itself. It is also left out
+     * of {@link BaseError.toJson | toJson()}, so a serialized validation error carries only its
+     * kind and message.
+     */
+    key?: string | undefined);
 }

package/dist/src/errors/ws-error.d.ts

@@ -1,5 +1,34 @@
 import { BaseError } from './base-error';
 
+/**
+ * The web socket the SDK uses for chat notifications failed to connect.
+ *
+ * Talks (V2) and Clips (V3) sessions open a web socket alongside the video stream; the agent's
+ * answer arrives over it as `partial` and `answer` events, which is what drives
+ * {@link AgentManagerCallbacks.onNewMessage | onNewMessage}. This error is raised when that socket
+ * emits an `error` event, once per failed attempt while
+ * {@link AgentManager.connect | connect()} is retrying. It is only delivered to
+ * {@link AgentManagerCallbacks.onError | onError} and never thrown, so there is nothing to catch
+ * around `connect()` for it; if every attempt fails, `connect()` rejects with the browser's own
+ * socket event instead.
+ *
+ * The socket is not opened at all for Expressive (V4) agents, which receive the same events over
+ * the LiveKit data channel, nor in {@link ChatMode.DirectPlayback | DirectPlayback} mode, so the
+ * error cannot occur in either case.
+ *
+ * {@link BaseError.kind | kind} is `'WSError'`, and the message is
+ * `'Websocket failed to connect'`.
+ *
+ * @category Errors
+ */
 export declare class WsError extends BaseError {
+    /**
+     * Always `'WSError'` — note the capitalization, which does not match the class name.
+     */
+    readonly kind: 'WSError';
+    /**
+     * Wraps a web socket failure, built from the socket's `error` event.
+     * @internal The SDK builds this itself; applications catch the error rather than construct it.
+     */
     constructor(message: string);
 }

package/dist/src/index.d.ts

@@ -1,6 +1,20 @@
-export * from './errors';
-export * from './services/agent-manager';
-export * from './types';
+export { createAgentManager } from './services/agent-manager';
+export type { Auth, BasicAuth, BearerToken, ClientKeyAuth } from './types/auth';
+export type { Agent, AgentAvatar, EndOfCallFeedbackConfig } from './types/entities/agents/agent';
+export type { AgentManager, AgentManagerCallbacks, AgentManagerOptions, StreamOptions, } from './types/entities/agents/manager';
+export { AvatarType } from './types/entities/avatar';
+export type { STTTokenResponse } from './types/voice/stt';
+export { AgentActivityState, ConnectionState, ConnectivityState, PublicDataChannelTopic, StreamEndReason, StreamEvents, StreamingState, } from './types/stream/stream';
+export type { ClientToolHandler, RunningToolCall, StreamCreatedInfo, ToolCallDonePayload, ToolCallErrorPayload, ToolCallStartedPayload, ToolEventCallback, ToolExecutionMode, } from './types/stream/stream';
+export type { SendStreamPayloadResponse } from './types/stream/rtc';
+export { StreamType } from './types/stream/stream';
+export type { CompatibilityMode } from './types/stream/stream';
+export type { AudioStreamScript, SupportedStreamScript, TextStreamScript } from './types/stream-script';
+export { ChatMode } from './types/entities/agents/chat';
+export type { ChatResponse, Interrupt, Message, MessagePart, MessageSentiment, RatingEntity, RetrievalMetadata, SubmitFeedbackResponse, } from './types/entities/agents/chat';
 export { parseMessageParts } from './utils/content-parser';
 export { isAwaitingTool } from './utils/tool-calls';
-export { SDK_VERSION } from './version';
+export { Providers, VoiceAccess } from './types/voice/tts';
+export type { AmazonTtsProvider, AzureOpenAiTtsProvider, ElevenlabsTtsProvider, MicrosoftTtsProvider, StreamTextToSpeechProviders, Voice, VoiceConfigElevenlabs, VoiceConfigMicrosoft, } from './types/voice/tts';
+export { BaseError, ChatCreationFailed, ChatModeDowngraded, HttpError, NetworkError, StreamError, ValidationError, WsError, isDIDError, } from './errors';
+export type { ErrorJson } from './errors';

package/dist/src/public-api.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/agent-manager/index.d.ts

@@ -2,6 +2,10 @@ import { AgentManager, AgentManagerOptions, Chat, ChatMode, CreateStreamOptions,
 import { SocketManager } from '../socket-manager';
 import { StreamingManager } from '../streaming-manager';
 
+/**
+ * Mutable state shared between the agent manager's connect/chat/stream helpers.
+ * @internal Implementation type; not part of the public SDK surface.
+ */
 export interface AgentManagerItems {
     chat?: Chat;
     streamingManager?: StreamingManager<CreateStreamOptions>;
@@ -10,15 +14,51 @@ export interface AgentManagerItems {
     chatMode: ChatMode;
 }
 /**
- * Creates a new Agent Manager instance for interacting with an agent, chat, and related connections.
+ * Creates an {@link AgentManager} for one agent: its chat, its video stream and its connections.
+ *
+ * Fetches the agent from the Agents API before it resolves, so the returned manager already has
+ * {@link AgentManager.agent | agent} and {@link AgentManager.starterMessages | starterMessages}
+ * filled in. No stream is opened until {@link AgentManager.connect | connect()} is called.
+ * {@link AgentManagerOptions.callbacks | callbacks} must include
+ * {@link AgentManagerCallbacks.onSrcObjectReady | onSrcObjectReady}, which is what attaches the
+ * streamed media to a video element.
  *
- * @param {string} agent - The ID or instance of the agent to chat with.
- * @param {AgentManagerOptions} options - Configurations for the Agent Manager API.
- * * @returns {Promise<AgentManager>} - A promise that resolves to an instance of the AgentsAPI interface.
+ * One option is checked here: an Expressive (V4) agent asked for {@link ChatMode.Off} or
+ * {@link ChatMode.DirectPlayback}, which only Talks (V2) and Clips (V3) agents support, rejects
+ * with a {@link ValidationError}. Every other bad argument surfaces later, as a
+ * {@link ValidationError} rejected by the method that was called on the returned manager, such as
+ * {@link AgentManager.chat | chat()} or {@link AgentManager.speak | speak()}.
  *
- * @throws {Error} Throws an error if the agent is not initialized.
+ * @param agent - Id of the agent to talk to: the `data-agent-id` from its Embed snippet, or the `id`
+ * returned by the Agents API.
+ * @param options - Credentials, callbacks and everything else the manager needs. See
+ * {@link AgentManagerOptions}.
+ * @returns A manager for that agent, ready to {@link AgentManager.connect | connect()}.
+ * @throws {@link ValidationError} When an Expressive (V4) agent is created with
+ * {@link ChatMode.Off} or {@link ChatMode.DirectPlayback}.
+ * @throws {@link HttpError} When the agent cannot be fetched — an unknown id, or a client key that
+ * is not authorized for the agent or the calling domain.
+ * @throws {@link NetworkError} When the request for the agent never reaches the server: the browser
+ * is offline, DNS or TLS fails, or the request is blocked.
  *
  * @example
- * const agentManager = await createAgentManager('id-agent123', { auth: { type: 'key', clientKey: '123', externalId: '123' } });
+ * ```ts
+ * import * as sdk from '@d-id/client-sdk';
+ *
+ * const agentManager = await sdk.createAgentManager('agt_fumf1234', {
+ *     auth: { type: 'key', clientKey: 'YOUR_CLIENT_KEY' },
+ *     callbacks: {
+ *         // Required: hand the streamed media to your video element.
+ *         onSrcObjectReady(value) {
+ *             videoElement.srcObject = value;
+ *         },
+ *     },
+ * });
+ *
+ * await agentManager.connect();
+ * await agentManager.chat('What is the distance to the moon?');
+ * ```
+ *
+ * @category Agent Manager
  */
 export declare function createAgentManager(agent: string, options: AgentManagerOptions): Promise<AgentManager>;

package/dist/src/services/chat/intial-messages.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/streaming-manager/common.d.ts

@@ -79,9 +79,14 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      */
     isInterruptible: boolean;
     /**
-     * Send an interrupt for the current stream segment
-     */
-    interrupt(type: Interrupt['type']): void;
+     * Send an interrupt for the current stream segment.
+     *
+     * Returns whether an interrupt was actually sent: `false` when there is nothing to interrupt
+     * (the stream does not support it, it is not a Fluent stream, no video is playing, or the
+     * interrupt type is one this transport drops), and `false` when the transport could not carry
+     * it because the connection or the data channel is not up.
+     */
+    interrupt(type: Interrupt['type']): boolean;
     /**
      * Register an RPC method handler on the LiveKit room.
      * Used internally by the agent-manager for client tool delegation.

package/dist/src/types/auth.d.ts

@@ -1,23 +1,95 @@
+/**
+ * A bearer token for the Agents API.
+ *
+ * Account-wide, so it is meant for a trusted environment — a server, a build step, an internal
+ * tool. Anyone who reads the token can spend the account's credits, so do not ship one in a page
+ * you serve to users; use {@link ClientKeyAuth} there. The SDK sends it as
+ * `Authorization: Bearer <token>~<connectionId>`, appending a per-connection id the D-ID
+ * authorizer strips before it validates the token.
+ *
+ * @category Authentication
+ */
 export interface BearerToken {
+    /**
+     * Discriminator selecting this variant of {@link Auth}.
+     */
     type: 'bearer';
+    /**
+     * The bearer token itself, sent in the `Authorization` header.
+     */
     token: string;
 }
+/**
+ * HTTP basic credentials for the Agents API, given either pre-encoded or as a username and
+ * password.
+ *
+ * Like {@link BearerToken} these are account-wide and belong in a trusted environment, never in a
+ * client bundle. The SDK sends them as `Authorization: Basic <credentials>~<connectionId>`, where
+ * the `token` form is used as the credentials as-is and the `username`/`password` form is
+ * base64-encoded as `username:password` first; the trailing per-connection id is stripped by the
+ * D-ID authorizer before the credentials are validated.
+ *
+ * @category Authentication
+ */
 export type BasicAuth = {
+    /**
+     * Discriminator selecting this variant of {@link Auth}.
+     */
     type: 'basic';
+    /**
+     * Credentials that are already base64-encoded, as `username:password`. Used as they
+     * are, so they are not encoded a second time.
+     */
     token: string;
 } | {
+    /**
+     * Discriminator selecting this variant of {@link Auth}.
+     */
     type: 'basic';
+    /**
+     * The account's user name; base64-encoded with the password before it is sent.
+     */
     username: string;
+    /**
+     * The account's password; base64-encoded with the user name before it is sent.
+     */
     password: string;
 };
+/**
+ * A client key for the Agents API — the credential to use in a browser.
+ *
+ * This is the one shape that is safe to ship in a page: a client key is scoped to a single agent
+ * and only works from the domains allowed for it, so it cannot be reused elsewhere. Copy it from the
+ * agent's Embed snippet, where it appears as `data-client-key`, or create one with the Agents API
+ * (see the link below). The SDK sends it
+ * as `Authorization: Client-Key <clientKey>.<externalId>_<connectionId>`, where the external id is
+ * either {@link AgentManagerOptions.externalId | externalId} or a per-browser id the SDK keeps in
+ * `localStorage`.
+ *
+ * @see [Create a client key](https://docs.d-id.com/reference/createclientkey)
+ * @category Authentication
+ */
 export interface ClientKeyAuth {
+    /**
+     * Discriminator selecting this variant of {@link Auth}.
+     */
     type: 'key';
+    /**
+     * The client key: the `data-client-key` value from the agent's Embed snippet, or a key created with
+     * the Agents API.
+     */
     clientKey: string;
 }
+/**
+ * The credentials {@link createAgentManager} accepts, as
+ * {@link AgentManagerOptions.auth | options.auth}.
+ *
+ * Pick {@link ClientKeyAuth} (`{ type: 'key', clientKey }`) for anything that runs in a browser: it
+ * is the only variant scoped to one agent and to the domains you allowed. {@link BearerToken} and
+ * {@link BasicAuth} carry account-wide credentials and belong in a trusted environment. Whichever
+ * you pass is used for every request the SDK makes — the REST calls, the video stream and the
+ * notifications web socket.
+ *
+ * @category Authentication
+ */
 export type Auth = BearerToken | BasicAuth | ClientKeyAuth;
-export interface GetAuthParams {
-    token?: string | null;
-    username?: string | null;
-    password?: string | null;
-    clientKey?: string | null;
-}