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

package/dist/src/types/stream/streams-v2.d.ts

@@ -1,6 +1,14 @@
+/**
+ * Transport used to establish a session created via the v2 sessions API.
+ * @internal Wire type of the streaming transport; not part of the public SDK surface.
+ */
 export declare enum TransportProvider {
     Livekit = "livekit"
 }
+/**
+ * Wire request body for creating a session via the v2 sessions API.
+ * @internal Wire type of the streaming transport; not part of the public SDK surface.
+ */
 export interface CreateSessionV2Options {
     transport: {
         provider: TransportProvider.Livekit;
@@ -8,6 +16,10 @@ export interface CreateSessionV2Options {
     chat_persist?: boolean;
     verbose?: boolean;
 }
+/**
+ * Wire response of the v2 sessions API's session-creation request.
+ * @internal Wire type of the streaming transport; not part of the public SDK surface.
+ */
 export interface CreateSessionV2Response {
     id: string;
     session_url: string;

package/dist/src/types/stream-script.d.ts

@@ -1,22 +1,53 @@
 import { Message } from './entities';
 import { StreamTextToSpeechProviders } from './voice/tts';
 
-export type StreamScriptType = 'text' | 'audio';
-export interface BaseStreamScript {
-    type: StreamScriptType;
-}
-export interface Stream_Text_Script extends BaseStreamScript {
+/**
+ * A script that makes the agent say text you supply, synthesised by a text-to-speech provider.
+ *
+ * The usual payload for {@link AgentManager.speak | speak()}. The agent's LLM is not involved, so
+ * the agent says exactly what {@link TextStreamScript.input | input} contains — which is what makes
+ * it the right script for greetings and other canned lines. Passing a plain string to
+ * {@link AgentManager.speak | speak()} is shorthand for this script with `ssml` set to `false`.
+ *
+ * @example Text
+ * ```ts
+ * const speak = await agentManager.speak({
+ *     type: 'text',
+ *     input: "Hi! I'm Alice!",
+ * });
+ * ```
+ * @example Text with sentiment
+ * `sentiment` is for Expressive (V4) agents only. If the requested sentiment is not supported by
+ * the agent, the default sentiment is used.
+ * ```ts
+ * const speak = await agentManager.speak({
+ *     type: 'text',
+ *     input: "Hi! I'm Alice!",
+ *     sentiment: 'friendly',
+ * });
+ * ```
+ * @category Speak & Scripts
+ */
+export interface TextStreamScript {
     /**
-     * The type of the script.
+     * Which kind of script this is. Always `text` for this variant; an
+     * {@link AudioStreamScript} carries `audio` instead.
      */
     type: 'text';
     /**
-     * text-to-speech provider from list of supported providers. default is microsoft tts
+     * The text-to-speech provider and voice that synthesise
+     * {@link TextStreamScript.input | input}, from the list of supported providers.
+     *
+     * One of the objects in {@link StreamTextToSpeechProviders}: a `type` naming the provider, the
+     * `voice_id` to speak with, and optional provider-specific `voice_config`. Leave it out and the
+     * SDK sends the script without a provider, so the voice is chosen server-side; the Agents API
+     * documents Microsoft TTS as its default when no provider is given.
      */
     provider?: StreamTextToSpeechProviders;
     /**
-     * The input text that will be synthesized to an audio file.
-     * Note that each provider has its own limitations on the text length.
+     * The text to be synthesised into speech.
+     *
+     * Each provider has its own limit on the text length.
      * @example "This is an example text"
      * @maxLength 40000
      * @minLength 3
@@ -24,33 +55,61 @@ export interface Stream_Text_Script extends BaseStreamScript {
     input: string;
     /**
      * Is the text provided in ssml form.
+     *
+     * Set it to `true` when {@link TextStreamScript.input | input} is SSML markup rather than plain
+     * text, so the provider reads the tags instead of speaking them.
      * @default false
      */
     ssml?: boolean;
     /**
-     * Queue this speak behind the current speech instead of interrupting it (expressive avatars only).
+     * Queue this speak behind the current speech instead of interrupting it. Expressive (V4)
+     * agents only.
      * @default false
      */
     should_queue_speaks?: boolean;
     /**
-     * Sentiment name to speak with (expressive avatars only).
-     * If the sentiment is not supported by the agent, the default sentiment is used.
+     * Sentiment name to speak with. Expressive (V4) agents only; if the agent does not support the
+     * requested sentiment, its default sentiment is used.
      * @example "friendly"
      */
     sentiment?: string;
 }
-export interface Stream_Audio_Script extends BaseStreamScript {
+/**
+ * A script that makes the agent lip-sync an audio file you host, with no text-to-speech involved.
+ *
+ * The other payload {@link AgentManager.speak | speak()} accepts. Use it when the audio already
+ * exists — a recording, or speech you synthesised yourself — instead of having a provider generate
+ * it from text.
+ *
+ * @example Audio file
+ * ```ts
+ * const speak = await agentManager.speak({
+ *     type: 'audio',
+ *     audio_url: 'https://www.yourwebsite.com/audio.mp3',
+ * });
+ * ```
+ * @category Speak & Scripts
+ */
+export interface AudioStreamScript {
     /**
-     * The type of the script.
+     * Which kind of script this is. Always `audio` for this variant; a
+     * {@link TextStreamScript} carries `text` instead.
      */
     type: 'audio';
     /**
-     * The URL of the audio file which will be used by the actor.
-     * File size is limit to 15MB.
+     * URL of the audio file the agent lip-syncs to.
+     *
+     * The URL has to be publicly reachable, since the file is fetched server-side rather than
+     * uploaded from the browser. The file may be at most 15 MB.
+     * @example "https://www.yourwebsite.com/audio.mp3"
      */
     audio_url: string;
 }
-export interface Stream_LLM_Script {
+/**
+ * Script variant that has the agent's LLM generate the response to speak, rather than supplying text or audio directly.
+ * @internal Implementation type; not part of the public SDK surface.
+ */
+export interface LlmStreamScript {
     type: 'llm';
     provider: StreamTextToSpeechProviders;
     ssml?: boolean;
@@ -61,5 +120,19 @@ export interface Stream_LLM_Script {
     input?: string;
     stream_audio?: boolean;
 }
-export type StreamScript = Stream_Text_Script | Stream_Audio_Script | Stream_LLM_Script;
-export type SupportedStreamScript = Stream_Text_Script | Stream_Audio_Script;
+/**
+ * Union of every script variant accepted internally, including the LLM-generated variant not exposed to consumers.
+ * @internal Implementation type; not part of the public SDK surface.
+ */
+export type StreamScript = TextStreamScript | AudioStreamScript | LlmStreamScript;
+/**
+ * The script payload {@link AgentManager.speak | speak()} accepts: text or audio.
+ *
+ * Discriminated by its `type` field, so `'text'` narrows the object to {@link TextStreamScript}
+ * and `'audio'` to {@link AudioStreamScript}.
+ * {@link AgentManager.speak | speak()} additionally takes a plain string, as shorthand for a
+ * {@link TextStreamScript} with that string as its `input`.
+ *
+ * @category Speak & Scripts
+ */
+export type SupportedStreamScript = TextStreamScript | AudioStreamScript;

package/dist/src/types/voice/stt.d.ts

@@ -1,4 +1,16 @@
+/**
+ * A short-lived credential for the D-ID speech-to-text service.
+ *
+ * What {@link AgentManager.getSTTToken | getSTTToken()} resolves with, fetched fresh from the
+ * Agents API each time. It lets an application drive its own speech recognition against the
+ * service the agent uses without putting D-ID credentials in the browser. The token expires, so request one per recognition session
+ * rather than holding on to it.
+ *
+ * @category Agent Manager
+ */
 export interface STTTokenResponse {
+    /** The authorization token to present to the speech service. */
     token: string;
+    /** The speech service region the token is valid in. */
     region: string;
 }

package/dist/src/types/voice/tts.d.ts

@@ -1,100 +1,175 @@
+/**
+ * The text-to-speech engines a voice can be served by.
+ *
+ * The value of the `type` field that discriminates the provider objects — {@link Providers.Microsoft}
+ * selects a {@link MicrosoftTtsProvider}, {@link Providers.Elevenlabs} an
+ * {@link ElevenlabsTtsProvider}, and so on — and of {@link Voice.provider} when you look a voice up
+ * in D-ID's catalogue. Which providers an account may use depends on its plan.
+ *
+ * @category Voice
+ */
 export declare enum Providers {
+    /** Amazon's text-to-speech service; see {@link AmazonTtsProvider}. */
     Amazon = "amazon",
+    /** Azure OpenAI text-to-speech; see {@link AzureOpenAiTtsProvider}. */
     AzureOpenAi = "azure-openai",
+    /** Microsoft Azure text-to-speech, which the Agents API documents as its default when a
+     * script names no provider; see {@link MicrosoftTtsProvider}. */
     Microsoft = "microsoft",
-    Afflorithmics = "afflorithmics",
+    /** ElevenLabs text-to-speech; see {@link ElevenlabsTtsProvider}. */
     Elevenlabs = "elevenlabs"
 }
+/**
+ * Who may use a voice.
+ *
+ * The value of {@link Voice.access}, so an application listing voices can show or hide the ones the
+ * account cannot select.
+ *
+ * @category Voice
+ */
 export declare enum VoiceAccess {
+    /** As exposed by the voices API: available to every account. */
     Public = "public",
+    /** As exposed by the voices API: available to accounts whose plan includes premium voices. */
     Premium = "premium",
+    /** As exposed by the voices API: available only to the account the voice belongs to. */
     Private = "private"
 }
-export interface IVoice {
+/**
+ * One voice in D-ID's catalogue of text-to-speech voices.
+ *
+ * The SDK does not fetch voices itself; the type is exported so an application that lists them —
+ * to build a voice picker, say — can type the result and then feed {@link Voice.id | id} and
+ * {@link Voice.provider | provider} into the provider object it passes as
+ * {@link TextStreamScript.provider}. {@link Voice.provider | provider} is the wide
+ * {@link Providers} enum, while each provider variant requires its own literal `type` — so switch
+ * on it to build the matching variant, for example {@link Providers.Elevenlabs} to an
+ * {@link ElevenlabsTtsProvider}.
+ *
+ * @category Voice
+ */
+export interface Voice {
+    /** Identifier of the voice: the value to pass as a provider object's `voice_id`. */
     id: string;
+    /** Human-readable name of the voice. */
     name: string;
+    /** The gender the voice is labelled with. */
     gender: string;
+    /** The locale the voice speaks, such as `en-US`. */
     locale: string;
+    /** Which accounts may use the voice. See {@link VoiceAccess}. */
     access: VoiceAccess;
+    /** The provider that serves the voice. See {@link Providers}. */
     provider: Providers;
+    /** The speaking styles this particular voice offers, for example as a
+     * {@link VoiceConfigMicrosoft.style | style}. Styles differ from voice to voice. */
     styles: string[];
+    /** The language of the voice, as a name rather than a locale code. */
     language: string;
 }
 /**
- * Elevenlabs provider details, contains the provider type and requested voice id, available for premium users.
+ * ElevenLabs provider details: the provider type and the requested voice id. Available to premium users.
+ *
+ * Pass it as {@link TextStreamScript.provider} to have ElevenLabs synthesise the text, optionally
+ * with {@link VoiceConfigElevenlabs} to control how closely the voice is reproduced.
+ *
+ * @category Voice
  */
-export interface Elevenlabs_tts_provider {
+export interface ElevenlabsTtsProvider {
+    /** Selects ElevenLabs. Always {@link Providers.Elevenlabs} (`'elevenlabs'`). */
     type: Providers.Elevenlabs;
     /**
-     * The voice_id from the list of available voices. https://api.elevenlabs.io/v1/voices.
+     * Id of the voice to speak with, from D-ID's list of ElevenLabs voices.
+     *
      * @example "21m00Tcm4TlvDq8ikWAM"
-     * @default 21m00Tcm4TlvDq8ikWAM
+     * @see [ElevenLabs voices](https://docs.d-id.com/docs/tts-elevenlabs)
      */
     voice_id: string;
     /**
-     * Voice customization options. Read more here: https://docs.elevenlabs.io/speech-synthesis/voice-settings
+     * How closely the voice should follow the original it was cloned from. See
+     * {@link VoiceConfigElevenlabs}.
+     *
+     * @see [ElevenLabs voice settings](https://elevenlabs.io/docs/best-practices/prompting/controls)
      */
     voice_config?: VoiceConfigElevenlabs;
 }
 /**
- * Afflorithmics provider details, contains the provider type and requested voice id, available for enterprise users.
- */
-export interface Afflorithmics_tts_provider {
-    type: Providers.Afflorithmics;
-    /**
-     * The voice_id from the list of available voices.
-     * @example "abc123DEF456"
-     * @default abc123DEF456
-     */
-    voice_id: string;
-    /**
-     * Voice customization options. Read more here: https://docs.audiostack.ai/reference/postspeech
-     */
-    voice_config?: VoiceConfigAfflorithmics;
-}
-/**
- * AzureMicrosoft provider details, contains the provider type and requested voice id and style
+ * Microsoft Azure provider details: the provider type, the requested voice id and an optional
+ * `voice_config` for style, rate and pitch.
+ *
+ * Pass it as {@link TextStreamScript.provider} to pick a Microsoft Azure voice explicitly,
+ * optionally with {@link VoiceConfigMicrosoft} to set style, rate and pitch. The Agents API
+ * documents Microsoft TTS as its default when a script names no provider, so this is also the
+ * provider a script without one ends up using.
+ *
+ * @category Voice
  */
-export interface Microsoft_tts_provider {
+export interface MicrosoftTtsProvider {
+    /** Selects Microsoft Azure. Always {@link Providers.Microsoft} (`'microsoft'`). */
     type: Providers.Microsoft;
     /**
-     * The voice_id from the list of available voices.
-     * For full list of voice_ids: https://docs.d-id.com/reference/microsoft-azure
+     * Id of the voice to speak with, from D-ID's list of Microsoft Azure voices.
+     *
      * @example "en-US-JennyNeural"
-     * @default en-US-JennyNeural
+     * @see [Microsoft Azure voices](https://docs.d-id.com/docs/tts-microsoft)
      */
     voice_id: string;
     /**
-     * Voice customization options
+     * How the voice should deliver the text: style, rate and pitch. See
+     * {@link VoiceConfigMicrosoft}.
      */
     voice_config?: VoiceConfigMicrosoft;
     /**
-     * Voice name
+     * @internal Not accepted by the Agents API, whose provider schema allows only `type`,
+     * `voice_id`, `voice_config` and `language`.
      */
     voice_name?: string;
     /**
-     * Voice language
+     * @internal Not accepted by the Agents API, whose provider schema allows only `type`,
+     * `voice_id`, `voice_config` and `language`.
      */
     voice_language?: string;
 }
 /**
- * AzureOpenAi provider details, contains the provider type and requested voice id and style
+ * Azure OpenAI provider details: the provider type, the requested voice id and an optional
+ * `voice_config` for style, rate and pitch.
+ *
+ * The same shape as {@link MicrosoftTtsProvider} — a `voice_id` and an optional
+ * {@link VoiceConfigMicrosoft} as `voice_config` — with the `type` naming Azure OpenAI instead.
+ *
+ * @category Voice
  */
-export interface AzureOpenAi_tts_provider extends Omit<Microsoft_tts_provider, 'type'> {
+export interface AzureOpenAiTtsProvider extends Omit<MicrosoftTtsProvider, 'type'> {
+    /** Selects Azure OpenAI. Always {@link Providers.AzureOpenAi} (`'azure-openai'`). */
     type: Providers.AzureOpenAi;
 }
 /**
- * Amazon provider details, contains the provider type and requested voice id
+ * Amazon provider details: the provider type and the requested voice id.
+ *
+ * Pass it as {@link TextStreamScript.provider} to have Amazon synthesise the text. It is the one
+ * provider with no `voice_config`: the voice is selected by `voice_id` alone.
+ *
+ * @category Voice
  */
-export interface Amazon_tts_provider {
+export interface AmazonTtsProvider {
+    /** Selects Amazon. Always {@link Providers.Amazon} (`'amazon'`). */
     type: Providers.Amazon;
     /**
-     * The voice_id from the list of available voices.
-     * For full list of voice_ids: https://docs.d-id.com/reference/text-to-speech-providers
+     * Id of the voice to speak with, from D-ID's list of Amazon voices.
+     *
      * @example "Joanna"
+     * @see [Amazon voices](https://docs.d-id.com/docs/tts-amazon)
      */
     voice_id: string;
 }
+/**
+ * How a Microsoft Azure or Azure OpenAI voice should deliver the text.
+ *
+ * The `voice_config` of {@link MicrosoftTtsProvider} and {@link AzureOpenAiTtsProvider}. Every
+ * field is optional; when one is omitted the Agents API applies its own default.
+ *
+ * @category Voice
+ */
 export interface VoiceConfigMicrosoft {
     /**
      * The style of the voice.
@@ -116,38 +191,48 @@ export interface VoiceConfigMicrosoft {
      */
     pitch?: string;
 }
+/**
+ * How closely an ElevenLabs voice should follow the original it was built from.
+ *
+ * The `voice_config` of {@link ElevenlabsTtsProvider}, mirroring ElevenLabs' own voice settings.
+ * Both fields are optional; when one is omitted the Agents API applies its own default.
+ *
+ * @category Voice
+ */
 export interface VoiceConfigElevenlabs {
     /**
-     * How stable the voice is and the randomness of each new generation.
-     * @example "0"
+     * How stable the voice is, and how much each generation varies.
+     *
+     * A number from 0 to 1: lower is more expressive and more variable between generations, higher
+     * is flatter and more repeatable.
+     * @example 0.5
      */
     stability?: number;
     /**
-     * The similarity slider dictates how closely the AI should adhere to the original voice when attempting to replicate it.
-     * @example "0"
+     * How closely the synthesised speech should adhere to the original voice it was cloned from.
+     *
+     * A number from 0 to 1: higher follows the original more strictly.
+     * @example 0.5
      */
     similarity_boost?: number;
 }
-export interface VoiceConfigAfflorithmics {
-    /**
-     * The speed of the voice.
-     * The value is relative to 1, 0.5 being half speed, 2 being twice as fast, etc.
-     * Another option is a constant value from x-slow/slow/medium/fast/x-fast.
-     * @example "1.2"
-     * @min 0.5
-     * @max 1.5
-     * @default 1
-     */
-    rate?: string;
-    /**
-     * Amount of microseconds for silence padding. Half of the amount is inserted as silence at the beginning and at the end of each Speech file.
-     */
-    silencePadding?: number;
-    /**
-     * Flag to apply lexicographical text corrections
-     */
-    voiceIntelligence?: boolean;
-}
-export type TextToSpeechProviders = Microsoft_tts_provider | AzureOpenAi_tts_provider | Afflorithmics_tts_provider | Elevenlabs_tts_provider;
-export type ExtendedTextToSpeechProviders = TextToSpeechProviders | Amazon_tts_provider;
-export type StreamTextToSpeechProviders = Microsoft_tts_provider | AzureOpenAi_tts_provider | Afflorithmics_tts_provider | Elevenlabs_tts_provider | Amazon_tts_provider;
+/**
+ * The provider object a speak script accepts: any of the four text-to-speech providers.
+ *
+ * This is the type of {@link TextStreamScript.provider}. Pick the variant for the provider you
+ * want, give it the `voice_id` to speak with and, except for {@link AmazonTtsProvider}, an optional
+ * `voice_config`; `type` discriminates the union.
+ *
+ * @example
+ * ```ts
+ * import { Providers } from '@d-id/client-sdk';
+ *
+ * const speak = await agentManager.speak({
+ *     type: 'text',
+ *     input: "Hi! I'm Alice!",
+ *     provider: { type: Providers.Microsoft, voice_id: 'en-US-JennyNeural' },
+ * });
+ * ```
+ * @category Voice
+ */
+export type StreamTextToSpeechProviders = MicrosoftTtsProvider | AzureOpenAiTtsProvider | ElevenlabsTtsProvider | AmazonTtsProvider;

package/dist/src/utils/analytics.d.ts

@@ -5,13 +5,13 @@ export declare function getAnalyticsInfo(agent: Agent): {
     isMobile: string;
     browser: string;
     origin: string;
-    agentType: "talk" | "clip" | "expressive" | "clip_v2";
+    agentType: import('../types/index').AvatarType | "clip_v2";
     agentVoice: {
         language: string | undefined;
     };
 };
 export declare function getAgentInfo(agent: Agent): {
-    agentType: "talk" | "clip" | "expressive" | "clip_v2";
+    agentType: import('../types/index').AvatarType | "clip_v2";
     presenterType: import('./agent').PresenterType;
     owner_id: string;
     starterQuestionsCount: number | undefined;

package/dist/src/utils/content-parser.d.ts

@@ -1,4 +1,35 @@
 import { MessagePart } from '../types/entities/agents/chat';
 
+/**
+ * Splits a message's text into the typed {@link MessagePart | parts} a UI can render.
+ *
+ * The SDK already runs it over every message it builds and keeps the result on
+ * {@link Message.parts}, so this is for content that comes from somewhere else — a transcript you
+ * render outside the SDK, or text you assembled before handing it to a renderer.
+ * {@link AgentManagerOptions.initialMessages | initialMessages} no longer need it: pass `parts: []`
+ * and the SDK runs this for you. It recognises markdown
+ * images (`![alt](url)`), the video thumbnail form (`[![alt](thumb)](video)`), markdown links
+ * (`[label](url)`) and HTML anchors (`<a href="url">label</a>`); an image whose URL looks like a
+ * video becomes a `video` part instead, and a GIF is tagged with a `mimeType`, both under the rules
+ * {@link MessagePart} sets out. Everything the parser does not recognise is preserved verbatim as a
+ * `text` part, in its original order, and nothing is dropped or reordered; each recognised part
+ * replaces the markup it was written as, so the parts are not a concatenation of the input.
+ *
+ * @param content - The message text to split, as it appears in {@link Message.content}.
+ * @returns The parts in the order they appear in `content`: a single `text` part when there is no
+ * markup to find, and an empty array for an empty string.
+ * @example
+ * ```ts
+ * import { parseMessageParts } from '@d-id/client-sdk';
+ *
+ * parseMessageParts('Here it is: ![a cat](https://example.com/cat.png) — enjoy!');
+ * // [
+ * //     { type: 'text', text: 'Here it is: ' },
+ * //     { type: 'image', src: 'https://example.com/cat.png', alt: 'a cat' },
+ * //     { type: 'text', text: ' — enjoy!' },
+ * // ]
+ * ```
+ * @category Chat
+ */
 export declare function parseMessageParts(content: string): MessagePart[];
 export declare function parseMessagePartsMemo(content: string): MessagePart[];

package/dist/src/utils/tool-calls.d.ts

@@ -2,7 +2,26 @@ import { RunningToolCall } from '../types';
 
 /**
  * Whether the agent is waiting on a tool call before it can continue.
- * True while any running call is 'blocking'. False when nothing is running,
- * or when everything running is 'async' and the agent is still available.
+ *
+ * True while any of the running calls is `blocking`; false when nothing is running, or when
+ * everything running is `async` and the agent can keep talking. Pass it the array
+ * {@link AgentManagerCallbacks.onRunningToolCallsChange | onRunningToolCallsChange} hands you, to
+ * decide whether to show the user that the agent is busy.
+ *
+ * @param calls - The tool calls running right now, as reported by
+ * {@link AgentManagerCallbacks.onRunningToolCallsChange | onRunningToolCallsChange}. See
+ * {@link RunningToolCall}.
+ * @returns `true` while the agent is suspended on a blocking tool call.
+ * @example
+ * ```ts
+ * import { isAwaitingTool } from '@d-id/client-sdk';
+ *
+ * const callbacks = {
+ *     onRunningToolCallsChange(calls) {
+ *         setSpinnerVisible(isAwaitingTool(calls));
+ *     },
+ * };
+ * ```
+ * @category Callbacks & Events
  */
 export declare function isAwaitingTool(calls: readonly RunningToolCall[]): boolean;

package/dist/src/version.d.ts

@@ -1 +1,7 @@
+/**
+ * Published version of the SDK this bundle was built from, `'dev'` when it runs from source.
+ * Attached to every analytics event.
+ *
+ * @internal
+ */
 export declare const SDK_VERSION: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@d-id/client-sdk",
   "private": false,
-  "version": "2.0.10",
+  "version": "3.0.0-staging.412",
   "type": "module",
   "description": "d-id client sdk",
   "repository": {
@@ -29,7 +29,9 @@
     "deploy:prod": "node ./infra/deploy.js --version beta",
     "preview": "vite preview",
     "test-build": "node .infra/build.js -m development",
-    "build:docs": "typedoc",
+    "docs:build": "typedoc",
+    "docs:check": "typedoc --out .docs-check-site",
+    "docs:serve": "yarn docs:build && vite preview --outDir docs-site --port 4173 --strictPort --open",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:ci": "jest --watchAll=false --passWithNoTests --verbose=false",
@@ -59,7 +61,9 @@
     "string-width": "^4.2.3",
     "strip-ansi": "^6.0.1",
     "ts-jest": "^29.4.1",
-    "typedoc": "^0.25.7",
+    "typedoc": "^0.28.20",
+    "typedoc-plugin-coverage": "^4.0.3",
+    "typedoc-plugin-mdn-links": "^5.1.1",
     "typescript": "^5.3.3",
     "vite": "^6.4.2",
     "vite-plugin-dts": "^3.7.3"

package/dist/src/types/entities/video.d.ts

@@ -1,6 +0,0 @@
-export declare enum VideoType {
-    Clip = "clip",
-    Talk = "talk",
-    Expressive = "expressive"
-}
-export declare const mapVideoType: (type: string) => VideoType;