@curvet/sdk 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -29,7 +29,7 @@ interface FetchResponse {
 interface FetchInit {
     method?: string;
     headers?: Record<string, string>;
-    body?: string;
+    body?: string | FormData;
     signal?: AbortSignal;
 }
 /** Injectable fetch implementation (defaults to global fetch on Node 18+). */
@@ -173,6 +173,17 @@ interface VideoGenerateParams {
     resolution?: string;
     [key: string]: unknown;
 }
+interface AudioGenerateParams {
+    model: ModelId;
+    prompt: string;
+    voice?: string;
+    [key: string]: unknown;
+}
+interface ThreeDGenerateParams {
+    model: ModelId;
+    prompt: string;
+    [key: string]: unknown;
+}
 interface PollOptions {
     /** Poll interval in ms (default 2500). */
     pollIntervalMs?: number;
@@ -211,32 +222,46 @@ declare class Job {
     wait(opts?: PollOptions): Promise<MediaJob>;
 }
 
+interface MediaParamsBase {
+    model: string;
+    prompt: string;
+    [key: string]: unknown;
+}
 /**
- * Video generation. Backed by an async job queue: `generate()` submits and
- * polls to completion (the common case); `submit()` fires and returns the job
- * handle for manual polling.
+ * Generic engine for the async media endpoints (video / audio / 3d). They all
+ * enqueue the same server-side job queue, so they share one implementation
+ * parameterized by `path` and request param type.
  *
- * The same implementation backs audio and 3D (v1.1) via the `path` arg.
+ * `generate()` submits and polls to completion; `submit()` fires without polling.
  */
-declare class Video {
-    private client;
-    private defaults;
-    private path;
-    constructor(client: HttpClient, defaults: JobDefaults, path?: string);
-    /**
-     * Submit a job WITHOUT polling. Returns once the server responds — either the
-     * 200 fast-path (already done) or a 202 with a jobId.
-     *
-     * The media POST long-polls server-side and can block well past a normal
-     * request timeout, so we default its timeout to the poll budget and disable
-     * auto-retry (a retried POST would enqueue a duplicate, double-charged job).
-     */
-    submit(params: VideoGenerateParams, options?: RequestOptions): Promise<MediaJob>;
+declare class MediaResource<P extends MediaParamsBase> {
+    protected client: HttpClient;
+    protected defaults: JobDefaults;
+    protected path: string;
+    constructor(client: HttpClient, defaults: JobDefaults, path: string);
     /**
-     * Submit and resolve to the finished media. Handles the 200-vs-202 split and
-     * polls `/jobs/:id` internally. Throws JobFailedError / JobTimeoutError.
+     * Submit WITHOUT polling. The media POST long-polls server-side and can block
+     * well past a normal request timeout, so we default its timeout to the poll
+     * budget and disable auto-retry (a retried POST would enqueue a duplicate job).
      */
-    generate(params: VideoGenerateParams, options?: RequestOptions & PollOptions): Promise<MediaJob>;
+    submit(params: P, options?: RequestOptions): Promise<MediaJob>;
+    /** Submit and resolve to the finished media (auto-polls /jobs/:id). */
+    generate(params: P, options?: RequestOptions & PollOptions): Promise<MediaJob>;
+}
+
+/** Video generation (async). `curvet.video.generate(...)` auto-polls to completion. */
+declare class Video extends MediaResource<VideoGenerateParams> {
+    constructor(client: HttpClient, defaults: JobDefaults);
+}
+
+/** Audio generation (async). `curvet.audio.generate(...)` auto-polls to completion. */
+declare class Audio extends MediaResource<AudioGenerateParams> {
+    constructor(client: HttpClient, defaults: JobDefaults);
+}
+
+/** 3D model generation (async). `curvet.threeD.generate(...)` auto-polls to completion. */
+declare class ThreeD extends MediaResource<ThreeDGenerateParams> {
+    constructor(client: HttpClient, defaults: JobDefaults);
 }
 
 interface ModelsListOptions extends RequestOptions {
@@ -285,11 +310,179 @@ declare class Balance {
     get(options?: RequestOptions): Promise<BalanceInfo>;
 }
 
+interface AnalyticsParams extends RequestOptions {
+    /** ISO 8601 start date. */
+    startDate?: string;
+    /** ISO 8601 end date. */
+    endDate?: string;
+}
+interface AnalyticsResult {
+    totalRequests?: number;
+    totalCost?: number;
+    requestsByModel?: Record<string, number>;
+    requestsByCategory?: Record<string, number>;
+    [key: string]: unknown;
+}
+declare class Analytics {
+    private client;
+    constructor(client: HttpClient);
+    /** Usage analytics for the app, optionally bounded by a date range. */
+    get(params?: AnalyticsParams): Promise<AnalyticsResult>;
+}
+
+interface WorkflowRunParams {
+    /** Input values for the workflow. */
+    inputs?: Record<string, unknown>;
+    /** Optional file inputs, keyed by the workflow's file field name. */
+    files?: Record<string, Blob>;
+    /** Include the full execution state in the response (default true server-side). */
+    includeFullState?: boolean;
+}
+/** Result of a synchronous `run()` call. */
+interface WorkflowRunResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+type WorkflowRunStatus = "queued" | "running" | "completed" | "failed" | "stopped";
+interface WorkflowRunNode {
+    nodeId: string;
+    nodeLabel?: string;
+    nodeType?: string;
+    status?: string;
+    executionTime?: number;
+}
+/** Normalized status of an async (pollable) workflow run. */
+interface WorkflowRun {
+    runId: string;
+    status: WorkflowRunStatus;
+    progress?: number;
+    totalNodes?: number;
+    completedNodeCount?: number;
+    /** The node currently executing (null when finished/queued). */
+    currentNode?: {
+        id: string;
+        label?: string;
+        type?: string;
+    } | null;
+    nodesExecuted?: WorkflowRunNode[];
+    /** Final outputs (present once completed). */
+    result?: unknown;
+    error?: string | null;
+    startTime?: string;
+    endTime?: string;
+    /** Raw, unnormalized response body. */
+    raw: unknown;
+}
+interface WorkflowSubmitResult {
+    runId: string;
+    status: WorkflowRunStatus;
+    raw: unknown;
+}
+interface WorkflowPollOptions {
+    /** Poll interval in ms (default 2500). */
+    pollIntervalMs?: number;
+    /** Total poll timeout in ms before throwing WorkflowRunTimeoutError (default 300000). */
+    pollTimeoutMs?: number;
+    signal?: AbortSignal;
+    /** Called on each poll tick with the latest run status (current node, progress). */
+    onProgress?: (run: WorkflowRun) => void;
+}
+/** Retrieve async workflow-run status. */
+declare class WorkflowRuns {
+    private client;
+    constructor(client: HttpClient);
+    /** Fetch the current status of an async run once (no polling). */
+    retrieve(runId: string, options?: RequestOptions): Promise<WorkflowRun>;
+}
+declare class Workflows {
+    private client;
+    readonly runs: WorkflowRuns;
+    constructor(client: HttpClient);
+    /**
+     * Execute a workflow synchronously (blocks until it finishes). Best for short
+     * workflows; for long ones (video/audio/3D nodes) prefer `runAndPoll`.
+     * Sends JSON, or multipart/form-data when file inputs are provided.
+     */
+    run(id: string, params?: WorkflowRunParams, options?: RequestOptions): Promise<WorkflowRunResult>;
+    /**
+     * Submit a workflow in async (pollable) mode — returns immediately with a
+     * runId. Poll `runs.retrieve(runId)` for status, or use `runAndPoll`.
+     */
+    submit(id: string, params?: WorkflowRunParams, options?: RequestOptions): Promise<WorkflowSubmitResult>;
+    /**
+     * Submit and poll to completion. Resolves with the completed run (including
+     * `result`), reporting progress via `onProgress`. Throws WorkflowRunFailedError
+     * on failure, WorkflowRunTimeoutError on timeout.
+     */
+    runAndPoll(id: string, params?: WorkflowRunParams, opts?: RequestOptions & WorkflowPollOptions): Promise<WorkflowRun>;
+}
+
+interface FoodItem {
+    [key: string]: unknown;
+}
+/**
+ * Indian Food Dataset API. Mounted as a sibling of the playground under
+ * `/api/v1/food`, so it uses the v1-root HTTP client. Requires the app to have
+ * Food API access enabled.
+ */
+declare class Food {
+    private client;
+    constructor(client: HttpClient);
+    /** List dishes (default limit 20). */
+    list(opts?: {
+        limit?: number;
+    } & RequestOptions): Promise<FoodItem[]>;
+    /** Full-text search for dishes. */
+    search(query: string, opts?: {
+        limit?: number;
+    } & RequestOptions): Promise<FoodItem[]>;
+    /** Natural-language dish recommendations. */
+    recommendations(prompt: string, options?: RequestOptions): Promise<FoodItem[]>;
+}
+
+interface SttParams {
+    /** The audio to transcribe. */
+    audio: Blob | Uint8Array | ArrayBuffer;
+    /** File name for the upload (default "audio"). */
+    filename?: string;
+    provider?: "elevenlabs" | "deepinfra" | (string & {});
+    /** ASR model id (provider-specific; optional). */
+    model?: string;
+    prompt?: string;
+    /** ISO 639-1 language hint. */
+    languageCode?: string;
+    allowFallback?: boolean;
+}
+interface SttResult {
+    success: boolean;
+    text: string;
+    languageCode?: string;
+    segments?: Array<{
+        start: number;
+        end: number;
+        text: string;
+    }>;
+    provider?: string;
+    creditsCharged?: number;
+    creditsRemaining?: number;
+    [key: string]: unknown;
+}
+/**
+ * Public speech-to-text. Mounted as a sibling of the playground under
+ * `/api/v1/voice`, so it uses the v1-root HTTP client. Multipart upload; not
+ * auto-retried (it consumes credits).
+ */
+declare class Voice {
+    private client;
+    constructor(client: HttpClient);
+    stt(params: SttParams, options?: RequestOptions): Promise<SttResult>;
+}
+
 declare const DEFAULT_BASE_URL = "https://curvet.ai/api/v1/playground";
 interface CurvetOptions {
     /** Your app key. Falls back to the CURVET_APP_KEY env var. */
     appKey?: string;
-    /** Override the gateway base URL (defaults to production). */
+    /** Override the playground base URL (defaults to production). */
     baseURL?: string;
     /** Per-request timeout in ms (default 60000). */
     timeout?: number;
@@ -317,9 +510,15 @@ declare class Curvet {
     readonly chat: Chat;
     readonly image: Images;
     readonly video: Video;
+    readonly audio: Audio;
+    readonly threeD: ThreeD;
     readonly jobs: Jobs;
     readonly models: Models;
     readonly balance: Balance;
+    readonly analytics: Analytics;
+    readonly workflows: Workflows;
+    readonly food: Food;
+    readonly voice: Voice;
     constructor(options?: CurvetOptions);
 }
 
@@ -376,5 +575,15 @@ declare class JobTimeoutError extends CurvetError {
     readonly jobId: string;
     constructor(message: string, jobId: string, opts?: CurvetErrorOptions);
 }
+/** An async workflow run finished with status "failed" (or "stopped"). */
+declare class WorkflowRunFailedError extends CurvetError {
+    readonly runId: string;
+    constructor(message: string, runId: string, opts?: CurvetErrorOptions);
+}
+/** An async workflow run did not finish within the poll timeout. */
+declare class WorkflowRunTimeoutError extends CurvetError {
+    readonly runId: string;
+    constructor(message: string, runId: string, opts?: CurvetErrorOptions);
+}
 
-export { APIError, AuthError, BadRequestError, Balance, type BalanceInfo, Chat, type ChatCreateParams, type ChatMessage, type ChatResponse, type ChatRole, ConnectionError, Curvet, CurvetError, type CurvetErrorOptions, type CurvetOptions, DEFAULT_BASE_URL, type FetchLike, type ImageGenerateParams, type ImageResponse, Images, InsufficientBalanceError, Job, type JobDefaults, JobFailedError, type JobStatus, JobTimeoutError, Jobs, type KnownModelId, type MediaJob, type MediaKind, type ModelId, type ModelInfo, type ModelType, Models, type ModelsListOptions, NotFoundError, PermissionError, type PollOptions, RateLimitError, type RateLimits, type RequestOptions, type Usage, Video, type VideoGenerateParams };
+export { APIError, Analytics, type AnalyticsParams, type AnalyticsResult, Audio, type AudioGenerateParams, AuthError, BadRequestError, Balance, type BalanceInfo, Chat, type ChatCreateParams, type ChatMessage, type ChatResponse, type ChatRole, ConnectionError, Curvet, CurvetError, type CurvetErrorOptions, type CurvetOptions, DEFAULT_BASE_URL, type FetchLike, Food, type FoodItem, type ImageGenerateParams, type ImageResponse, Images, InsufficientBalanceError, Job, type JobDefaults, JobFailedError, type JobStatus, JobTimeoutError, Jobs, type KnownModelId, type MediaJob, type MediaKind, type MediaParamsBase, MediaResource, type ModelId, type ModelInfo, type ModelType, Models, type ModelsListOptions, NotFoundError, PermissionError, type PollOptions, RateLimitError, type RateLimits, type RequestOptions, type SttParams, type SttResult, ThreeD, type ThreeDGenerateParams, type Usage, Video, type VideoGenerateParams, Voice, type WorkflowPollOptions, type WorkflowRun, WorkflowRunFailedError, type WorkflowRunNode, type WorkflowRunParams, type WorkflowRunResult, type WorkflowRunStatus, WorkflowRunTimeoutError, WorkflowRuns, type WorkflowSubmitResult, Workflows };

package/dist/index.js

@@ -37,6 +37,18 @@ var JobTimeoutError = class extends CurvetError {
     this.jobId = jobId;
   }
 };
+var WorkflowRunFailedError = class extends CurvetError {
+  constructor(message, runId, opts = {}) {
+    super(message, opts);
+    this.runId = runId;
+  }
+};
+var WorkflowRunTimeoutError = class extends CurvetError {
+  constructor(message, runId, opts = {}) {
+    super(message, opts);
+    this.runId = runId;
+  }
+};
 function errorFromResponse(status, body, requestId, headers) {
   const b = body ?? {};
   const message = typeof b.error === "string" ? b.error : `HTTP ${status}`;
@@ -125,8 +137,12 @@ var HttpClient = class {
     };
     let payload;
     if (body !== void 0) {
-      headers["content-type"] = "application/json";
-      payload = JSON.stringify(body);
+      if (typeof FormData !== "undefined" && body instanceof FormData) {
+        payload = body;
+      } else {
+        headers["content-type"] = "application/json";
+        payload = JSON.stringify(body);
+      }
     }
     let attempt = 0;
     for (; ; ) {
@@ -360,20 +376,17 @@ var Job = class {
   }
 };
 
-// src/resources/video.ts
-var Video = class {
-  constructor(client, defaults, path = "/video") {
+// src/resources/media.ts
+var MediaResource = class {
+  constructor(client, defaults, path) {
     this.client = client;
     this.defaults = defaults;
     this.path = path;
   }
   /**
-   * Submit a job WITHOUT polling. Returns once the server responds — either the
-   * 200 fast-path (already done) or a 202 with a jobId.
-   *
-   * The media POST long-polls server-side and can block well past a normal
-   * request timeout, so we default its timeout to the poll budget and disable
-   * auto-retry (a retried POST would enqueue a duplicate, double-charged job).
+   * Submit WITHOUT polling. The media POST long-polls server-side and can block
+   * well past a normal request timeout, so we default its timeout to the poll
+   * budget and disable auto-retry (a retried POST would enqueue a duplicate job).
    */
   async submit(params, options) {
     const reqOptions = {
@@ -389,10 +402,7 @@ var Video = class {
     });
     return normalizeMediaPost(body);
   }
-  /**
-   * Submit and resolve to the finished media. Handles the 200-vs-202 split and
-   * polls `/jobs/:id` internally. Throws JobFailedError / JobTimeoutError.
-   */
+  /** Submit and resolve to the finished media (auto-polls /jobs/:id). */
   async generate(params, options) {
     const submitted = await this.submit(params, options);
     if (submitted.status === "completed" || submitted.status === "failed") {
@@ -413,6 +423,27 @@ var Video = class {
   }
 };
 
+// src/resources/video.ts
+var Video = class extends MediaResource {
+  constructor(client, defaults) {
+    super(client, defaults, "/video");
+  }
+};
+
+// src/resources/audio.ts
+var Audio = class extends MediaResource {
+  constructor(client, defaults) {
+    super(client, defaults, "/audio");
+  }
+};
+
+// src/resources/threeD.ts
+var ThreeD = class extends MediaResource {
+  constructor(client, defaults) {
+    super(client, defaults, "/3d");
+  }
+};
+
 // src/resources/models.ts
 var Models = class {
   constructor(client, cacheTtlMs = 6e4) {
@@ -465,6 +496,227 @@ var Balance = class {
   }
 };
 
+// src/resources/analytics.ts
+var Analytics = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Usage analytics for the app, optionally bounded by a date range. */
+  async get(params = {}) {
+    const { startDate, endDate, ...options } = params;
+    const body = await this.client.request({
+      method: "GET",
+      path: "/analytics",
+      query: { startDate, endDate },
+      options
+    });
+    return body.analytics;
+  }
+};
+
+// src/resources/workflows.ts
+function normalizeRun(body) {
+  const b = body ?? {};
+  return {
+    runId: b.runId,
+    status: b.status,
+    progress: b.progress,
+    totalNodes: b.totalNodes,
+    completedNodeCount: b.completedNodeCount,
+    currentNode: b.currentNode ?? null,
+    nodesExecuted: b.nodesExecuted,
+    result: b.result,
+    error: b.error ?? null,
+    startTime: b.startTime,
+    endTime: b.endTime,
+    raw: body
+  };
+}
+function buildBody(params, extra = {}) {
+  const hasFiles = params.files && Object.keys(params.files).length > 0;
+  if (hasFiles) {
+    const form = new FormData();
+    form.append("inputs", JSON.stringify(params.inputs ?? {}));
+    if (params.includeFullState !== void 0) {
+      form.append("includeFullState", String(params.includeFullState));
+    }
+    for (const [k, v] of Object.entries(extra)) form.append(k, String(v));
+    for (const [field, file] of Object.entries(params.files)) {
+      form.append(field, file);
+    }
+    return form;
+  }
+  return {
+    inputs: params.inputs ?? {},
+    includeFullState: params.includeFullState,
+    ...extra
+  };
+}
+var WorkflowRuns = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Fetch the current status of an async run once (no polling). */
+  async retrieve(runId, options) {
+    const body = await this.client.request({
+      method: "GET",
+      path: `/workflows/runs/${encodeURIComponent(runId)}`,
+      options
+    });
+    return normalizeRun(body);
+  }
+};
+var Workflows = class {
+  constructor(client) {
+    this.client = client;
+    this.runs = new WorkflowRuns(client);
+  }
+  /**
+   * Execute a workflow synchronously (blocks until it finishes). Best for short
+   * workflows; for long ones (video/audio/3D nodes) prefer `runAndPoll`.
+   * Sends JSON, or multipart/form-data when file inputs are provided.
+   */
+  async run(id, params = {}, options) {
+    const reqOptions = { ...options, maxRetries: options?.maxRetries ?? 0 };
+    return this.client.request({
+      method: "POST",
+      path: `/workflows/${encodeURIComponent(id)}/run`,
+      body: buildBody(params),
+      options: reqOptions
+    });
+  }
+  /**
+   * Submit a workflow in async (pollable) mode — returns immediately with a
+   * runId. Poll `runs.retrieve(runId)` for status, or use `runAndPoll`.
+   */
+  async submit(id, params = {}, options) {
+    const reqOptions = { ...options, maxRetries: options?.maxRetries ?? 0 };
+    const res = await this.client.request({
+      method: "POST",
+      path: `/workflows/${encodeURIComponent(id)}/run`,
+      body: buildBody(params, { async: true }),
+      options: reqOptions
+    });
+    return { runId: res?.runId, status: res?.status ?? "running", raw: res };
+  }
+  /**
+   * Submit and poll to completion. Resolves with the completed run (including
+   * `result`), reporting progress via `onProgress`. Throws WorkflowRunFailedError
+   * on failure, WorkflowRunTimeoutError on timeout.
+   */
+  async runAndPoll(id, params = {}, opts = {}) {
+    const submitted = await this.submit(id, params, opts);
+    if (!submitted.runId) {
+      throw new CurvetError("Workflow submit did not return a runId", {
+        raw: submitted.raw
+      });
+    }
+    const intervalMs = opts.pollIntervalMs ?? 2500;
+    const timeoutMs = opts.pollTimeoutMs ?? 3e5;
+    let run;
+    try {
+      run = await pollUntil(
+        () => this.runs.retrieve(submitted.runId, { signal: opts.signal }),
+        {
+          intervalMs,
+          timeoutMs,
+          signal: opts.signal,
+          isTerminal: (r) => r.status === "completed" || r.status === "failed" || r.status === "stopped",
+          onTick: (r) => opts.onProgress?.(r)
+        }
+      );
+    } catch (e) {
+      if (e instanceof PollTimeoutError) {
+        throw new WorkflowRunTimeoutError(
+          `Workflow run ${submitted.runId} did not finish within ${timeoutMs}ms`,
+          submitted.runId
+        );
+      }
+      throw e;
+    }
+    if (run.status === "failed" || run.status === "stopped") {
+      throw new WorkflowRunFailedError(
+        run.error || `Workflow run ${submitted.runId} ${run.status}`,
+        submitted.runId,
+        { raw: run.raw }
+      );
+    }
+    return run;
+  }
+};
+
+// src/resources/food.ts
+var Food = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List dishes (default limit 20). */
+  async list(opts) {
+    const { limit, ...options } = opts ?? {};
+    const body = await this.client.request({
+      method: "GET",
+      path: "/food",
+      query: { limit },
+      options
+    });
+    return body.data;
+  }
+  /** Full-text search for dishes. */
+  async search(query, opts) {
+    const { limit, ...options } = opts ?? {};
+    const body = await this.client.request({
+      method: "GET",
+      path: "/food/search",
+      query: { q: query, limit },
+      options
+    });
+    return body.data;
+  }
+  /** Natural-language dish recommendations. */
+  async recommendations(prompt, options) {
+    const body = await this.client.request({
+      method: "POST",
+      path: "/food/recommendations",
+      body: { prompt },
+      options
+    });
+    return body.data;
+  }
+};
+
+// src/resources/voice.ts
+var Voice = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async stt(params, options) {
+    const form = new FormData();
+    form.append("audio", toBlob(params.audio), params.filename ?? "audio");
+    if (params.provider) form.append("provider", params.provider);
+    if (params.model) form.append("model", params.model);
+    if (params.prompt) form.append("prompt", params.prompt);
+    if (params.languageCode) form.append("languageCode", params.languageCode);
+    if (params.allowFallback !== void 0) {
+      form.append("allowFallback", String(params.allowFallback));
+    }
+    const reqOptions = {
+      ...options,
+      timeout: options?.timeout ?? 12e4,
+      maxRetries: options?.maxRetries ?? 0
+    };
+    return this.client.request({
+      method: "POST",
+      path: "/voice/stt/public",
+      body: form,
+      options: reqOptions
+    });
+  }
+};
+function toBlob(audio) {
+  if (typeof Blob !== "undefined" && audio instanceof Blob) return audio;
+  return new Blob([audio]);
+}
+
 // src/client.ts
 var DEFAULT_BASE_URL = "https://curvet.ai/api/v1/playground";
 var Curvet = class {
@@ -481,13 +733,16 @@ var Curvet = class {
         "No fetch implementation available. Use Node 18+ or pass { fetch }."
       );
     }
-    const client = new HttpClient({
+    const playgroundBase = options.baseURL ?? DEFAULT_BASE_URL;
+    const v1Base = playgroundBase.replace(/\/playground\/?$/, "");
+    const shared = {
       appKey,
-      baseURL: options.baseURL ?? DEFAULT_BASE_URL,
       timeout: options.timeout ?? 6e4,
       maxRetries: options.maxRetries ?? 2,
       fetch: fetchImpl
-    });
+    };
+    const client = new HttpClient({ ...shared, baseURL: playgroundBase });
+    const v1Client = new HttpClient({ ...shared, baseURL: v1Base });
     const jobDefaults = {
       pollIntervalMs: options.defaultPollIntervalMs ?? 2500,
       pollTimeoutMs: options.defaultPollTimeoutMs ?? 18e4
@@ -496,8 +751,14 @@ var Curvet = class {
     this.image = new Images(client);
     this.jobs = new Jobs(client, jobDefaults);
     this.video = new Video(client, jobDefaults);
+    this.audio = new Audio(client, jobDefaults);
+    this.threeD = new ThreeD(client, jobDefaults);
     this.models = new Models(client);
     this.balance = new Balance(client);
+    this.analytics = new Analytics(client);
+    this.workflows = new Workflows(client);
+    this.food = new Food(v1Client);
+    this.voice = new Voice(v1Client);
   }
 };
 function envKey() {
@@ -509,6 +770,8 @@ function defaultFetch() {
 }
 export {
   APIError,
+  Analytics,
+  Audio,
   AuthError,
   BadRequestError,
   Balance,
@@ -517,16 +780,24 @@ export {
   Curvet,
   CurvetError,
   DEFAULT_BASE_URL,
+  Food,
   Images,
   InsufficientBalanceError,
   Job,
   JobFailedError,
   JobTimeoutError,
   Jobs,
+  MediaResource,
   Models,
   NotFoundError,
   PermissionError,
   RateLimitError,
-  Video
+  ThreeD,
+  Video,
+  Voice,
+  WorkflowRunFailedError,
+  WorkflowRunTimeoutError,
+  WorkflowRuns,
+  Workflows
 };
 //# sourceMappingURL=index.js.map