@decartai/sdk 0.1.13 → 0.1.15

package/README.md

@@ -164,23 +164,38 @@ realtimeClient.on("connectionQuality", (report) => { /* ... */ });
 realtimeClient.getConnectionQuality(); // latest report, or null before the first sample
 ```
 
+> `onConnectionQuality` and the `connectionQuality` event are **debounced** — they only re-fire
+> when the verdict (`quality`/`limitingFactor`) changes, so they're not a live metrics feed. For a
+> continuous read of the raw numbers, updated every stats tick (~1/s), use the `stats` event or
+> poll `getConnectionQuality()?.metrics`:
+>
+> ```typescript
+> realtimeClient.on("stats", (s) => updateLatencyHud(s.glassToGlass?.medianMs, s.video?.framesPerSecond));
+> // or, on your own interval:
+> setInterval(() => console.log(realtimeClient.getConnectionQuality()?.metrics.g2gMs), 1000);
+> ```
+
 **Glass-to-glass latency (opt-in, diagnostic).** Network RTT hides the dominant cost in
 real-time video — model inference — so a session can read "good" while actually feeling laggy.
-Set `debugQuality: true` to measure the *real* camera→display latency: the SDK stamps a pixel
-marker into each outgoing frame and reads it back off the rendered output, surfacing **startup**
-(`ttffMs`) and **steady-state** (`g2gMs`) latency plus end-to-end frame drops (`g2gDropRatio`).
-When present, glass-to-glass drives the latency verdict instead of RTT.
+Set `debugQuality: true` to measure the *real* camera→display latency. The SDK attaches a capture
+timestamp using LiveKit frame metadata; the server propagates it through inference and the SDK
+matches it to output playout. This surfaces **startup** (`ttffMs`) and **steady-state**
+(`g2gMs`) latency. When present, glass-to-glass drives the latency verdict instead of RTT.
 
-> ⚠️ Diagnostic only. The marker is **visible** (bottom-left of the published and rendered video)
-> and adds per-frame pixel work — don't enable it for production / end-user sessions.
+> Frame metadata is currently experimental in LiveKit and requires encoded-transform support.
+> It does not alter visible pixels. `g2gDropRatio` remains `null` until frame IDs are propagated
+> through the server pipeline as well as timestamps.
 
 ```typescript
 const realtimeClient = await client.realtime.connect(stream, {
   model,
   debugQuality: true,
-  onConnectionQuality: ({ quality, metrics }) => {
-    console.log(metrics.ttffMs, metrics.g2gMs, metrics.g2gDropRatio);
-  },
+});
+
+// g2g updates every stats tick — read it from the `stats` event (the
+// `connectionQuality` verdict is debounced and would go stale between changes):
+realtimeClient.on("stats", ({ glassToGlass }) => {
+  console.log(glassToGlass?.ttffMs, glassToGlass?.medianMs);
 });
 ```
 
@@ -243,6 +258,90 @@ if (status.status === "completed") {
 }
 ```
 
+### React Native / Expo
+
+React Native realtime requires [LiveKit's React Native packages](https://github.com/livekit/client-sdk-react-native)
+and an early `registerGlobals()` call. Plain `react-native-webrtc` is not
+supported. SDK imports and `createDecartClient(...)` usage stay the same.
+
+```sh
+npm install @decartai/sdk livekit-client@2.20.1 \
+  @livekit/react-native@2.11.1 \
+  @livekit/react-native-webrtc@144.1.1
+```
+
+Call LiveKit setup from a side-effect module that runs before your router or app
+entrypoint:
+
+```ts
+// livekit-bootstrap.ts
+import { registerGlobals } from "@livekit/react-native";
+
+registerGlobals();
+```
+
+```ts
+// index.ts
+import "./livekit-bootstrap";
+import "expo-router/entry"; // or import your root App component
+```
+
+With the globals registered, realtime usage is the same as on the web. Use the
+model's numeric FPS when configuring native camera capture, then pass that
+`MediaStream` to the SDK:
+
+```ts
+import { createDecartClient, models, resolveFpsNumber } from "@decartai/sdk";
+import { mediaDevices } from "@livekit/react-native-webrtc";
+
+const client = createDecartClient({ apiKey: "your-api-key-here" });
+const model = models.realtime("lucy-2.5");
+const captureFps = resolveFpsNumber(model.fps);
+
+const cameraStream = await mediaDevices.getUserMedia({
+  audio: false,
+  video: {
+    facingMode: "user",
+    frameRate: captureFps,
+    width: model.width,
+    height: model.height,
+  },
+});
+
+const realtimeClient = await client.realtime.connect(cameraStream, {
+  model,
+  preferredVideoCodec: "vp8",
+  onRemoteStream,
+});
+```
+
+For Expo, install the config plugins:
+
+```sh
+npm install @livekit/react-native-expo-plugin@1.0.2 \
+  @config-plugins/react-native-webrtc
+```
+
+Add them to `app.json`:
+
+```json
+{
+  "expo": {
+    "plugins": [
+      "@livekit/react-native-expo-plugin",
+      "@config-plugins/react-native-webrtc"
+    ]
+  }
+}
+```
+
+Run `npx expo prebuild` and rebuild the native app. LiveKit does not run in Expo
+Go. Bare React Native apps must follow LiveKit's native setup instructions.
+
+Outgoing `mirror`, `debugQuality`, and deep connectivity preflight are browser-only
+and fail with `UNSUPPORTED_PLATFORM_FEATURE` on React Native. Mirror the local
+preview with your native video view instead.
+
 ## Development
 
 ### Setup
@@ -273,4 +372,4 @@ The package is published to npm as `@decartai/sdk`.
 
 ## License
 
-MIT
+MIT

package/dist/create-client.d.ts

@@ -0,0 +1,46 @@
+import { Logger } from "./utils/logger.js";
+
+//#region src/create-client.d.ts
+type DecartClientOptions = {
+  proxy: string;
+  apiKey?: never;
+  baseUrl?: string;
+  realtimeBaseUrl?: string;
+  integration?: string;
+  logger?: Logger;
+  telemetry?: boolean;
+} | {
+  proxy?: never;
+  apiKey?: string;
+  baseUrl?: string;
+  realtimeBaseUrl?: string;
+  integration?: string;
+  logger?: Logger;
+  telemetry?: boolean;
+};
+/**
+ * Create a Decart API client.
+ *
+ * @param options - Configuration options
+ * @param options.proxy - URL of the proxy server. When set, the client will use the proxy instead of direct API access and apiKey is not required.
+ * @param options.apiKey - API key for authentication.
+ * @param options.baseUrl - Override the default API base URL.
+ * @param options.realtimeBaseUrl - Override the default WebSocket base URL for realtime connections.
+ * @param options.integration - Optional integration identifier.
+ *
+ * Realtime media uses LiveKit only (inference must enable it in `TRANSPORTS_ENABLED`).
+ *
+ * @example
+ * ```ts
+ * // Option 1: Explicit API key (direct API access)
+ * const client = createDecartClient({ apiKey: "your-api-key" });
+ *
+ * // Option 2: Using DECART_API_KEY environment variable
+ * const client = createDecartClient();
+ *
+ * // Option 3: Using proxy (client-side, no API key needed)
+ * const client = createDecartClient({ proxy: "https://your-server.com/api/decart" });
+ * ```
+ */
+//#endregion
+export { DecartClientOptions };

package/dist/create-client.js

@@ -0,0 +1,208 @@
+import { createInvalidApiKeyError, createInvalidBaseUrlError } from "./utils/errors.js";
+import { createFilesClient } from "./files/client.js";
+import { createProcessClient } from "./process/client.js";
+import { createQueueClient } from "./queue/client.js";
+import { createTokensClient } from "./tokens/client.js";
+import { readEnv } from "./utils/env.js";
+import { createConsoleLogger } from "./utils/logger.js";
+import { z } from "zod";
+//#region src/create-client.ts
+const proxySchema = z.union([z.string().url(), z.string().startsWith("/")]);
+const decartClientOptionsSchema = z.object({
+	apiKey: z.string().min(1).optional(),
+	baseUrl: z.url().optional(),
+	proxy: proxySchema.optional(),
+	integration: z.string().optional(),
+	realtimeBaseUrl: z.url().optional()
+}).refine((data) => {
+	const hasProxy = !!data.proxy;
+	const hasApiKey = !!data.apiKey;
+	return !(hasProxy && hasApiKey);
+}, { message: "Cannot provide both 'proxy' and 'apiKey'. Use 'proxy' for proxy mode or 'apiKey' for direct API access." });
+/**
+* Create a Decart API client.
+*
+* @param options - Configuration options
+* @param options.proxy - URL of the proxy server. When set, the client will use the proxy instead of direct API access and apiKey is not required.
+* @param options.apiKey - API key for authentication.
+* @param options.baseUrl - Override the default API base URL.
+* @param options.realtimeBaseUrl - Override the default WebSocket base URL for realtime connections.
+* @param options.integration - Optional integration identifier.
+*
+* Realtime media uses LiveKit only (inference must enable it in `TRANSPORTS_ENABLED`).
+*
+* @example
+* ```ts
+* // Option 1: Explicit API key (direct API access)
+* const client = createDecartClient({ apiKey: "your-api-key" });
+*
+* // Option 2: Using DECART_API_KEY environment variable
+* const client = createDecartClient();
+*
+* // Option 3: Using proxy (client-side, no API key needed)
+* const client = createDecartClient({ proxy: "https://your-server.com/api/decart" });
+* ```
+*/
+const createDecartClientForPlatform = (createRealtime, options = {}) => {
+	const parsedOptions = decartClientOptionsSchema.safeParse(options);
+	if (!parsedOptions.success) {
+		const issue = parsedOptions.error.issues[0];
+		if (issue.path.includes("apiKey")) throw createInvalidApiKeyError();
+		if (issue.path.includes("baseUrl") || issue.path.includes("realtimeBaseUrl")) throw createInvalidBaseUrlError(options[issue.path.includes("realtimeBaseUrl") ? "realtimeBaseUrl" : "baseUrl"]);
+		if (issue.path.includes("proxy")) throw createInvalidBaseUrlError(issue.path.includes("proxy") ? options.proxy : void 0);
+		throw parsedOptions.error;
+	}
+	const isProxyMode = "proxy" in parsedOptions.data && !!parsedOptions.data.proxy;
+	const apiKey = isProxyMode ? void 0 : ("apiKey" in parsedOptions.data ? parsedOptions.data.apiKey : void 0) ?? readEnv("DECART_API_KEY");
+	if (!isProxyMode && !apiKey) throw createInvalidApiKeyError();
+	let baseUrl;
+	if (isProxyMode && "proxy" in parsedOptions.data && parsedOptions.data.proxy) baseUrl = parsedOptions.data.proxy;
+	else baseUrl = parsedOptions.data.baseUrl || "https://api.decart.ai";
+	const { integration } = parsedOptions.data;
+	const logger = "logger" in options && options.logger ? options.logger : createConsoleLogger("info");
+	const telemetryEnabled = !("telemetry" in options && options.telemetry === false);
+	const wsBaseUrl = parsedOptions.data.realtimeBaseUrl || "wss://api3.decart.ai";
+	const realtime = createRealtime({
+		publishBaseUrl: wsBaseUrl,
+		subscribeBaseUrl: isProxyMode || parsedOptions.data.baseUrl !== void 0 ? baseUrl : wsBaseUrl.replace(/^wss?:\/\//i, "https://"),
+		apiKey: apiKey || "",
+		integration,
+		logger,
+		telemetryEnabled
+	});
+	const process = createProcessClient({
+		baseUrl,
+		apiKey: apiKey || "",
+		integration
+	});
+	const queue = createQueueClient({
+		baseUrl,
+		apiKey: apiKey || "",
+		integration
+	});
+	const tokens = createTokensClient({
+		baseUrl,
+		apiKey: apiKey || "",
+		integration
+	});
+	const files = createFilesClient({
+		baseUrl,
+		apiKey: apiKey || "",
+		integration
+	});
+	return {
+		realtime: {
+			connect: realtime.connect,
+			subscribe: realtime.subscribe,
+			/**
+			* Check whether the user's network can support a real-time session
+			* *before* connecting — so you can gate showing the integration.
+			*
+			* Default (STUN-only): validates WebRTC reachability (UDP egress / TURN
+			* need) and approximate latency via a throwaway peer connection — no
+			* session, instant. Opt-in deep probe (`{ deep: true, model }`): briefly
+			* opens a real session with a synthetic source and measures *true*
+			* glass-to-glass latency (plus upstream loss/jitter),
+			* then tears it down — accurate, but costs a short GPU session.
+			*
+			* @example
+			* ```ts
+			* // Fast, pre-session reachability check
+			* const { quality, reasons } = await client.realtime.checkConnectivity();
+			* if (quality === "critical") showFallbackUI(reasons);
+			*
+			* // Accurate, measured glass-to-glass verdict
+			* const probe = await client.realtime.checkConnectivity({ deep: true, model: models.realtime("lucy-restyle-2") });
+			* console.log(probe.metrics.g2gMs);
+			* ```
+			*/
+			checkConnectivity: realtime.checkConnectivity
+		},
+		/**
+		* Client for synchronous image generation.
+		* Only image models support the sync/process API.
+		*
+		* @example
+		* ```ts
+		* const client = createDecartClient({ apiKey: "your-api-key" });
+		* const result = await client.process({
+		*   model: models.image("lucy-pro-i2i"),
+		*   prompt: "Transform into anime style",
+		*   data: imageBlob
+		* });
+		* ```
+		*/
+		process,
+		/**
+		* Client for queue-based async video generation.
+		* Only video models support the queue API.
+		* Jobs are submitted and processed asynchronously.
+		*
+		* @example
+		* ```ts
+		* const client = createDecartClient({ apiKey: "your-api-key" });
+		*
+		* // Option 1: Submit and poll automatically
+		* const result = await client.queue.submitAndPoll({
+		*   model: models.video("lucy-pro-v2v"),
+		*   prompt: "Transform into anime style",
+		*   data: videoBlob,
+		*   onStatusChange: (job) => console.log(`Job ${job.job_id}: ${job.status}`)
+		* });
+		*
+		* // Option 2: Submit and poll manually
+		* const job = await client.queue.submit({
+		*   model: models.video("lucy-pro-v2v"),
+		*   prompt: "Transform into anime style",
+		*   data: videoBlob
+		* });
+		*
+		* // Poll until completion
+		* while (true) {
+		*   const status = await client.queue.status(job.job_id);
+		*   console.log(`Job ${status.job_id}: ${status.status}`);
+		*
+		*   if (status.status === "completed") {
+		*     const blob = await client.queue.result(job.job_id);
+		*     break;
+		*   }
+		*   if (status.status === "failed") {
+		*     throw new Error("Job failed");
+		*   }
+		*   await new Promise(resolve => setTimeout(resolve, 1500));
+		* }
+		* ```
+		*/
+		queue,
+		/**
+		* Client for creating client tokens.
+		* Client tokens are short-lived API keys safe for client-side use.
+		*
+		* @example
+		* ```ts
+		* // Server-side: Create a client token
+		* const serverClient = createDecartClient({ apiKey: process.env.DECART_API_KEY });
+		* const token = await serverClient.tokens.create();
+		* // Returns: { apiKey: "ek_...", expiresAt: "2024-12-15T12:10:00Z" }
+		*
+		* // Client-side: Use the client token
+		* const client = createDecartClient({ apiKey: token.apiKey });
+		* const realtimeClient = await client.realtime.connect(stream, options);
+		* ```
+		*/
+		tokens,
+		/**
+		* Upload files once and reuse them across generations.
+		*
+		* @example
+		* ```ts
+		* const ref = await client.files.upload(blob);
+		* await rt.set({ image: ref.id, prompt: "make it cinematic" });
+		* await rt.set({ image: ref.id, prompt: "now in noir" });
+		* ```
+		*/
+		files
+	};
+};
+//#endregion
+export { createDecartClientForPlatform };

package/dist/files/types.js

@@ -1,4 +1,7 @@
+//#region src/files/types.ts
+/** Prefix on every uploaded-file id; disambiguates a ref string from base64. */
+const FILE_REF_PREFIX = "file_";
 /** True if `value` is a `"file_..."` reference id from `client.files.upload(...)`. */
 const isFileRefId = (value) => typeof value === "string" && value.startsWith("file_");
 //#endregion
-export { isFileRefId };
+export { FILE_REF_PREFIX, isFileRefId };

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { LogLevel, Logger, createConsoleLogger, noopLogger } from "./utils/logger.js";
-import { CanonicalModel, CustomModelDefinition, ImageModelDefinition, ImageModels, ListedModelDefinition, Model, ModelDefinition, ModelKind, RealTimeModels, VideoModelDefinition, VideoModels, isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, models, resolveCanonicalModelAlias, resolveModelAlias } from "./shared/model.js";
+import { CanonicalModel, CustomModelDefinition, ImageModelDefinition, ImageModels, ListedModelDefinition, Model, ModelDefinition, ModelFps, ModelKind, RealTimeModels, VideoModelDefinition, VideoModels, isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, models, resolveCanonicalModelAlias, resolveFpsNumber, resolveModelAlias } from "./shared/model.js";
 import { FileInput, ProcessOptions, ReactNativeFile } from "./process/types.js";
 import { FileReference, FileUploadInput } from "./files/types.js";
 import { FilesClient, UploadFileOptions } from "./files/client.js";
@@ -7,172 +6,31 @@ import { ProcessClient } from "./process/client.js";
 import { JobStatus, JobStatusResponse, JobSubmitResponse, QueueJobResult, QueueSubmitAndPollOptions, QueueSubmitOptions } from "./queue/types.js";
 import { QueueClient } from "./queue/client.js";
 import { DecartSDKError, ERROR_CODES } from "./utils/errors.js";
-import { G2GMetrics } from "./realtime/observability/glass-to-glass.js";
+import { LogLevel, Logger, createConsoleLogger, noopLogger } from "./utils/logger.js";
+import { G2GMetrics } from "./realtime/observability/g2g.js";
 import { WebRTCStats } from "./realtime/observability/webrtc-stats.js";
 import { ConnectionQuality, ConnectionQualityLimitingFactor, ConnectionQualityMetrics, ConnectionQualityReport } from "./realtime/observability/connection-quality.js";
 import { ClientSessionConnectionBreakdownEvent, ClientSessionConnectionBreakdownPhase, DiagnosticEvent, DiagnosticEventName, DiagnosticEvents, ReconnectEvent, VideoStallEvent } from "./realtime/observability/diagnostics.js";
 import { ConnectionState, GenerationEndedMessage, QueuePosition, QueuePositionMessage } from "./realtime/types.js";
 import { SetInput } from "./realtime/methods.js";
-import { Events, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState } from "./realtime/client.js";
-import { CheckConnectivityOptions, ConnectivityMetrics, ConnectivityReport, ConnectivityTransport } from "./realtime/preflight.js";
+import { Events, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState, RealtimeMediaStream } from "./realtime/client.js";
+import { CheckConnectivityOptions, ConnectivityMetrics, ConnectivityReport, ConnectivityTransport } from "./realtime/preflight-types.js";
 import { RealTimeSubscribeClient, SubscribeEvents, SubscribeOptions } from "./realtime/subscribe-client.js";
 import { ModelState } from "./shared/types.js";
 import { CreateTokenOptions, CreateTokenResponse, TokensClient } from "./tokens/client.js";
+import { DecartClientOptions } from "./create-client.js";
 
 //#region src/index.d.ts
-type DecartClientOptions = {
-  proxy: string;
-  apiKey?: never;
-  baseUrl?: string;
-  realtimeBaseUrl?: string;
-  integration?: string;
-  logger?: Logger;
-  telemetry?: boolean;
-} | {
-  proxy?: never;
-  apiKey?: string;
-  baseUrl?: string;
-  realtimeBaseUrl?: string;
-  integration?: string;
-  logger?: Logger;
-  telemetry?: boolean;
-};
-/**
- * Create a Decart API client.
- *
- * @param options - Configuration options
- * @param options.proxy - URL of the proxy server. When set, the client will use the proxy instead of direct API access and apiKey is not required.
- * @param options.apiKey - API key for authentication.
- * @param options.baseUrl - Override the default API base URL.
- * @param options.realtimeBaseUrl - Override the default WebSocket base URL for realtime connections.
- * @param options.integration - Optional integration identifier.
- *
- * Realtime media uses LiveKit only (inference must enable it in `TRANSPORTS_ENABLED`).
- *
- * @example
- * ```ts
- * //  (direct API access)Option 1: Explicit API key
- * const client = createDecartClient({ apiKey: "your-api-key" });
- *
- * // Option 2: Using DECART_API_KEY environment variable
- * const client = createDecartClient();
- *
- * // Option 3: Using proxy (client-side, no API key needed)
- * const client = createDecartClient({ proxy: "https://your-server.com/api/decart" });
- * ```
- */
 declare const createDecartClient: (options?: DecartClientOptions) => {
   realtime: {
-    connect: (stream: MediaStream | null, options: RealTimeClientConnectOptions) => Promise<RealTimeClient>;
+    connect: <TStream extends RealtimeMediaStream = MediaStream>(stream: TStream | null, options: RealTimeClientConnectOptions<TStream>) => Promise<RealTimeClient>;
     subscribe: (options: SubscribeOptions) => Promise<RealTimeSubscribeClient>;
-    /**
-     * Check whether the user's network can support a real-time session
-     * *before* connecting — so you can gate showing the integration.
-     *
-     * Default (STUN-only): validates WebRTC reachability (UDP egress / TURN
-     * need) and approximate latency via a throwaway peer connection — no
-     * session, instant. Opt-in deep probe (`{ deep: true, model }`): briefly
-     * opens a real session with a synthetic source and measures *true*
-     * glass-to-glass latency (and end-to-end drops / upstream loss+jitter),
-     * then tears it down — accurate, but costs a short GPU session.
-     *
-     * @example
-     * ```ts
-     * // Fast, pre-session reachability check
-     * const { quality, reasons } = await client.realtime.checkConnectivity();
-     * if (quality === "critical") showFallbackUI(reasons);
-     *
-     * // Accurate, measured glass-to-glass verdict
-     * const probe = await client.realtime.checkConnectivity({ deep: true, model: models.realtime("mirage") });
-     * console.log(probe.metrics.g2gMs);
-     * ```
-     */
     checkConnectivity: (options?: CheckConnectivityOptions) => Promise<ConnectivityReport>;
   };
-  /**
-   * Client for synchronous image generation.
-   * Only image models support the sync/process API.
-   *
-   * @example
-   * ```ts
-   * const client = createDecartClient({ apiKey: "your-api-key" });
-   * const result = await client.process({
-   *   model: models.image("lucy-pro-i2i"),
-   *   prompt: "Transform into anime style",
-   *   data: imageBlob
-   * });
-   * ```
-   */
   process: ProcessClient;
-  /**
-   * Client for queue-based async video generation.
-   * Only video models support the queue API.
-   * Jobs are submitted and processed asynchronously.
-   *
-   * @example
-   * ```ts
-   * const client = createDecartClient({ apiKey: "your-api-key" });
-   *
-   * // Option 1: Submit and poll automatically
-   * const result = await client.queue.submitAndPoll({
-   *   model: models.video("lucy-pro-v2v"),
-   *   prompt: "Transform into anime style",
-   *   data: videoBlob,
-   *   onStatusChange: (job) => console.log(`Job ${job.job_id}: ${job.status}`)
-   * });
-   *
-   * // Option 2: Submit and poll manually
-   * const job = await client.queue.submit({
-   *   model: models.video("lucy-pro-v2v"),
-   *   prompt: "Transform into anime style",
-   *   data: videoBlob
-   * });
-   *
-   * // Poll until completion
-   * while (true) {
-   *   const status = await client.queue.status(job.job_id);
-   *   console.log(`Job ${status.job_id}: ${status.status}`);
-   *
-   *   if (status.status === "completed") {
-   *     const blob = await client.queue.result(job.job_id);
-   *     break;
-   *   }
-   *   if (status.status === "failed") {
-   *     throw new Error("Job failed");
-   *   }
-   *   await new Promise(resolve => setTimeout(resolve, 1500));
-   * }
-   * ```
-   */
   queue: QueueClient;
-  /**
-   * Client for creating client tokens.
-   * Client tokens are short-lived API keys safe for client-side use.
-   *
-   * @example
-   * ```ts
-   * // Server-side: Create a client token
-   * const serverClient = createDecartClient({ apiKey: process.env.DECART_API_KEY });
-   * const token = await serverClient.tokens.create();
-   * // Returns: { apiKey: "ek_...", expiresAt: "2024-12-15T12:10:00Z" }
-   *
-   * // Client-side: Use the client token
-   * const client = createDecartClient({ apiKey: token.apiKey });
-   * const realtimeClient = await client.realtime.connect(stream, options);
-   * ```
-   */
   tokens: TokensClient;
-  /**
-   * Upload files once and reuse them across generations.
-   *
-   * @example
-   * ```ts
-   * const ref = await client.files.upload(blob);
-   * await rt.set({ image: ref.id, prompt: "make it cinematic" });
-   * await rt.set({ image: ref.id, prompt: "now in noir" });
-   * ```
-   */
   files: FilesClient;
 };
 //#endregion
-export { type CanonicalModel, type CheckConnectivityOptions, type ClientSessionConnectionBreakdownEvent, type ClientSessionConnectionBreakdownPhase, type ConnectionQuality, type ConnectionQualityLimitingFactor, type ConnectionQualityMetrics, type ConnectionQualityReport, type ConnectionState, type ConnectivityMetrics, type ConnectivityReport, type ConnectivityTransport, type CreateTokenOptions, type CreateTokenResponse, type CustomModelDefinition, DecartClientOptions, type DecartSDKError, type DiagnosticEvent, type DiagnosticEventName, type DiagnosticEvents, ERROR_CODES, type FileInput, type FileReference, type FileUploadInput, type FilesClient, type G2GMetrics, type GenerationEndedMessage, type ImageModelDefinition, type ImageModels, type JobStatus, type JobStatusResponse, type JobSubmitResponse, type ListedModelDefinition, type LogLevel, type Logger, type Model, type ModelDefinition, type ModelKind, type ModelState, type ProcessClient, type ProcessOptions, type QueueClient, type QueueJobResult, type QueuePosition, type QueuePositionMessage, type QueueSubmitAndPollOptions, type QueueSubmitOptions, type ReactNativeFile, type RealTimeClient, type RealTimeClientConnectOptions, type RealTimeClientInitialState, type Events as RealTimeEvents, type RealTimeModels, type RealTimeSubscribeClient, type ReconnectEvent, type SetInput, type SubscribeEvents, type SubscribeOptions, type TokensClient, type UploadFileOptions, type VideoModelDefinition, type VideoModels, type VideoStallEvent, type WebRTCStats, createConsoleLogger, createDecartClient, isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, models, noopLogger, resolveCanonicalModelAlias, resolveModelAlias };
+export { CanonicalModel, CheckConnectivityOptions, ClientSessionConnectionBreakdownEvent, ClientSessionConnectionBreakdownPhase, ConnectionQuality, ConnectionQualityLimitingFactor, ConnectionQualityMetrics, ConnectionQualityReport, ConnectionState, ConnectivityMetrics, ConnectivityReport, ConnectivityTransport, CreateTokenOptions, CreateTokenResponse, CustomModelDefinition, type DecartClientOptions, DecartSDKError, DiagnosticEvent, DiagnosticEventName, DiagnosticEvents, ERROR_CODES, FileInput, FileReference, FileUploadInput, FilesClient, G2GMetrics, GenerationEndedMessage, ImageModelDefinition, ImageModels, JobStatus, JobStatusResponse, JobSubmitResponse, ListedModelDefinition, LogLevel, Logger, Model, ModelDefinition, ModelFps, ModelKind, ModelState, ProcessClient, ProcessOptions, QueueClient, QueueJobResult, QueuePosition, QueuePositionMessage, QueueSubmitAndPollOptions, QueueSubmitOptions, ReactNativeFile, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState, Events as RealTimeEvents, RealTimeModels, RealTimeSubscribeClient, RealtimeMediaStream, ReconnectEvent, SetInput, SubscribeEvents, SubscribeOptions, TokensClient, UploadFileOptions, VideoModelDefinition, VideoModels, VideoStallEvent, WebRTCStats, createConsoleLogger, createDecartClient, isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, models, noopLogger, resolveCanonicalModelAlias, resolveFpsNumber, resolveModelAlias };