@acedatacloud/sdk 2026.718.1 → 2026.727.0

package/src/resources/providers/localization.ts

@@ -0,0 +1,45 @@
+/**
+ * Localization (localization) — generated from the platform OpenAPI spec.
+ *
+ * Do not edit by hand: run `python scripts/generate_providers.py`. Parameter
+ * names, types, enums and required-ness all come from the live spec.
+ */
+
+import { Transport } from '../../runtime/transport';
+
+
+export interface LocalizationTranslateOptions {
+  /** Please provide the content that needs to be translated. */
+  input: Record<string, unknown>;
+  /** The target language area to be translated to. */
+  locale: "en" | "de" | "pt" | "es" | "fr" | "zh-CN" | "zh-TW" | "it" | "ko" | "ja" | "ru" | "pl" | "fi" | "sv" | "el" | "uk" | "ar" | "sr";
+  /** The file type of the input text (such as `json` or `md`). */
+  extension: "json" | "md";
+  /** The large language model used for translation is `gpt-3.5` by default. */
+  model?: "gpt-3.5" | "gpt-4";
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+/** localization client. */
+export class Localization {
+  constructor(private transport: Transport) {}
+
+  /** Translate a JSON input into any localized file */
+  async translate(options: LocalizationTranslateOptions): Promise<Record<string, unknown>> {
+    const body: Record<string, unknown> = {};
+    body["input"] = options.input;
+    body["locale"] = options.locale;
+    body["extension"] = options.extension;
+    if (options.model !== undefined) body["model"] = options.model;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "callbackUrl", "extension", "input", "locale", "maxWait", "model", "pollInterval", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    return (await this.transport.request('POST', "/localization/translate", { json: body })) as Record<string, unknown>;
+  }
+
+}

package/src/resources/providers/luma.ts

@@ -0,0 +1,83 @@
+/**
+ * Luma (luma) — generated from the platform OpenAPI spec.
+ *
+ * Do not edit by hand: run `python scripts/generate_providers.py`. Parameter
+ * names, types, enums and required-ness all come from the live spec.
+ */
+
+import { Transport } from '../../runtime/transport';
+import { TaskHandle } from '../../runtime/tasks';
+
+
+function taskId(result: Record<string, unknown>): string {
+  if (typeof result?.task_id === 'string') return result.task_id;
+  const data = result?.data as Record<string, unknown> | undefined;
+  if (data && typeof data.task_id === 'string') return data.task_id;
+  return typeof result?.id === 'string' ? result.id : '';
+}
+
+export interface LumaGenerateOptions {
+  /** Whether to enable loop playback for the generated video. */
+  loop?: boolean;
+  /** Operation type. Use `generate` when creating a video for the first time, and use `extend` when continuing an existing video. */
+  action?: "generate" | "extend";
+  /** Text prompts for generating videos. */
+  prompt?: string;
+  /** The timeout for the API return data (unit: seconds). */
+  timeout?: number;
+  /** The unique identifier of the generated video used for the continuation operation (`extend`). If both are specified, `video_id` takes precedence over `video_url`. */
+  videoId?: string;
+  /** The original video URL used for the extend operation (`extend`). If `video_id` is specified at the same time, then `video_id` shall prevail. */
+  videoUrl?: string;
+  /** Whether to enable automatic optimization enhancement for the input prompt text, suitable for use when unsure how to write prompt words. */
+  enhancement?: boolean;
+  /** Generate the aspect ratio of the video, for example `16:9`. */
+  aspectRatio?: string;
+  /** The URL of the ending frame image, which will be used as the last frame of the generated video. */
+  endImageUrl?: string;
+  /** The URL of the starting frame image, which will be used as the first frame of the generated video. */
+  startImageUrl?: string;
+  /** Submit asynchronously and poll. Defaults to true. */
+  async?: boolean;
+  /** Wait for completion before returning the handle. */
+  wait?: boolean;
+  pollInterval?: number;
+  maxWait?: number;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+/** luma client. */
+export class Luma {
+  constructor(private transport: Transport) {}
+
+  /** Generate videos based on prompt and image frames */
+  async generate(options: LumaGenerateOptions = {}): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["loop"] = options.loop ?? false;
+    body["action"] = options.action ?? "generate";
+    body["prompt"] = options.prompt ?? "Astronauts shuttle from space to volcano";
+    body["timeout"] = options.timeout ?? 300;
+    if (options.videoId !== undefined) body["video_id"] = options.videoId;
+    if (options.videoUrl !== undefined) body["video_url"] = options.videoUrl;
+    body["enhancement"] = options.enhancement ?? true;
+    if (options.aspectRatio !== undefined) body["aspect_ratio"] = options.aspectRatio;
+    body["end_image_url"] = options.endImageUrl ?? "https://cdn.acedata.cloud/0iad3k.png";
+    body["start_image_url"] = options.startImageUrl ?? "https://cdn.acedata.cloud/r9vsv9.png";
+    for (const [key, value] of Object.entries(options)) {
+      if (!["action", "aspectRatio", "async", "callbackUrl", "endImageUrl", "enhancement", "loop", "maxWait", "pollInterval", "prompt", "startImageUrl", "timeout", "videoId", "videoUrl", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    body.async = options.async ?? true;
+    const result = (await this.transport.request('POST', "/luma/videos", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/luma/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}

package/src/resources/providers/maestro.ts

@@ -0,0 +1,84 @@
+/**
+ * Maestro (maestro) — generated from the platform OpenAPI spec.
+ *
+ * Do not edit by hand: run `python scripts/generate_providers.py`. Parameter
+ * names, types, enums and required-ness all come from the live spec.
+ */
+
+import { Transport } from '../../runtime/transport';
+
+
+export interface MaestroGenerateOptions {
+  /** Natural-language brief describing the video to produce (the topic, what to show, tone, audience). The agent decides the script, visuals, voiceover and edit. */
+  prompt: string;
+  /** Output languages, e.g. ["zh-cn", "en"]. The first is the primary language; each additional one reuses the visuals with a localized voiceover + render and is billed +6 credits. */
+  langs?: string[];
+  /** Optional visual-style preset — expressed through typography, palette, motion, image treatment and pacing. Orthogonal to `scenario` (it does NOT change routing). `auto` (default) lets the director pick; every other value adopts a real named look: `cinematic` = dark film-noir (black + blood-red, Oswald); `glass` = Apple / iOS-26 frosted liquid glass; `luxury` = timeless near-black + indigo, huge whitespace; `swiss` = precise grid + electric blue + oversized numerals; `modern` = clean light SaaS; `editorial` = cream magazine + serif; `warm` = intimate cream + amber; `vibrant` = festive folk colour; `neon` = electric neon glow; `mono` = grayscale, type-led; `pastel` = soft candy pastels; `bold` = huge poster type; `industrial` = raw glitch + rust; `futuristic` = particle glow. A freeform string is also accepted as a soft hint. */
+  style?: "auto" | "cinematic" | "glass" | "luxury" | "swiss" | "modern" | "editorial" | "warm" | "vibrant" | "neon" | "mono" | "pastel" | "bold" | "industrial" | "futuristic" | "retro";
+  /** Optional narration voice — the **timbre** of the voiceover, independent of language. `auto` (default) lets the director pick a fitting voice. Every preset is cross-lingual: the same voice speaks whatever language(s) you set in `langs`, so choose purely by character — `warm-female`, `bright-female`, `anchor-female`, `clean-female`, `calm-male`, `deep-male`, `documentary-male`, `energetic-male`, `storyteller-male`. Advanced: a raw 32-character Fish `reference_id` is also accepted. For `drama` / `avatar` this sets the primary / narrator timbre; distinct characters may still get their own. */
+  voice?: "auto" | "warm-female" | "bright-female" | "anchor-female" | "clean-female" | "calm-male" | "deep-male" | "documentary-male" | "energetic-male" | "storyteller-male";
+  /** generate = a new video. remix / edit / extend = iterate on a previous video (require `ref_task_id`). */
+  action?: "generate" | "remix" | "edit" | "extend";
+  /** Output aspect ratio (hint — the agent may follow the prompt). */
+  aspect?: "9:16" | "16:9" | "1:1";
+  /** Production tier, a multiplier on the duration-based price. `draft` = a fast rough cut for previewing the idea (~0.5× the standard credits); `standard` = balanced (default, 1×); `premium` = richer, more detailed and polished (~2× the standard credits). Affects turnaround, detail and price. */
+  quality?: "draft" | "standard" | "premium";
+  /** Target video length in seconds (1–600, i.e. up to 10 minutes). Billed by duration: credits ≈ 0.85 × duration × quality multiplier × scenario multiplier, so a longer or video-native workflow costs proportionally more. */
+  duration?: number;
+  /** How to route the video — a hint; the AI director still decides the final structure. `auto` (default) = the director chooses from your brief. `narrated` = multi-scene narrated video with real photos + voiceover + data cards (people / brands / explainers / history / products). `drama` = acted short drama with characters + dialogue (短剧) and bills at 1.35×. `avatar` = talking-head / digital human (needs a portrait image via `file_urls`, or a chosen digital human) and bills at 1.15×. `motion` = abstract kinetic-typography / data / logo motion graphic. `slideshow` = presentation deck / pitch. Legacy values `general` / `explainer` / `product` / `website` / `changelog` / `captions` are still accepted (mapped to `auto`), and `slides` maps to `slideshow`. */
+  scenario?: "auto" | "narrated" | "drama" | "avatar" | "motion" | "slideshow";
+  /** Optional reference media (image / video / audio URLs) the agent can use — e.g. a product shot or logo to feature, footage to caption. */
+  fileUrls?: string[];
+  /** Required when `action` is remix / edit / extend: the task_id of the previous video to start from. */
+  refTaskId?: string;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+export interface MaestroEstimatesOptions {
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+/** maestro client. */
+export class Maestro {
+  constructor(private transport: Transport) {}
+
+  /** Maestro Video Generation API */
+  async generate(options: MaestroGenerateOptions): Promise<Record<string, unknown>> {
+    const body: Record<string, unknown> = {};
+    body["prompt"] = options.prompt;
+    body["langs"] = options.langs ?? ["zh-cn"];
+    body["style"] = options.style ?? "auto";
+    body["voice"] = options.voice ?? "auto";
+    body["action"] = options.action ?? "generate";
+    body["aspect"] = options.aspect ?? "9:16";
+    body["quality"] = options.quality ?? "standard";
+    body["duration"] = options.duration ?? 30;
+    body["scenario"] = options.scenario ?? "auto";
+    if (options.fileUrls !== undefined) body["file_urls"] = options.fileUrls;
+    if (options.refTaskId !== undefined) body["ref_task_id"] = options.refTaskId;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["action", "aspect", "async", "callbackUrl", "duration", "fileUrls", "langs", "maxWait", "pollInterval", "prompt", "quality", "refTaskId", "scenario", "style", "voice", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    return (await this.transport.request('POST', "/maestro/videos", { json: body })) as Record<string, unknown>;
+  }
+
+  /** Call /maestro/estimates. */
+  async estimates(options: MaestroEstimatesOptions = {}): Promise<Record<string, unknown>> {
+    const body: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "callbackUrl", "maxWait", "pollInterval", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    return (await this.transport.request('POST', "/maestro/estimates", { json: body })) as Record<string, unknown>;
+  }
+
+}

package/src/resources/providers/nano-banana.ts

@@ -0,0 +1,74 @@
+/**
+ * NanoBanana (nano-banana) — generated from the platform OpenAPI spec.
+ *
+ * Do not edit by hand: run `python scripts/generate_providers.py`. Parameter
+ * names, types, enums and required-ness all come from the live spec.
+ */
+
+import { Transport } from '../../runtime/transport';
+import { TaskHandle } from '../../runtime/tasks';
+
+
+function taskId(result: Record<string, unknown>): string {
+  if (typeof result?.task_id === 'string') return result.task_id;
+  const data = result?.data as Record<string, unknown> | undefined;
+  if (data && typeof data.task_id === 'string') return data.task_id;
+  return typeof result?.id === 'string' ? result.id : '';
+}
+
+export interface NanoBananaGenerateOptions {
+  /** Image operation type. If it is `generate`, then generate an image based on the prompt; if it is `edit`, then edit the image based on the prompt and `image_urls`. */
+  action: "generate" | "edit";
+  /** Prompts for generating images. */
+  prompt: string;
+  /** The number of images to be generated or edited supports 1 to 4, with a default of 1. If some images fail to generate, the corresponding `data` only contains the successfully generated images and charges based on the number of successful ones. */
+  count?: number;
+  /** Models used for generating images. If not specified, the default is `nano-banana`. `nano-banana-2-lite` is an alias for `gemini-3.1-flash-lite-image` (only 1K, fast generation speed), `nano-banana-2` is an alias for `gemini-3.1-flash-image` (provides professional-level quality at flash speed), `nano-banana-pro` is an alias for `gemini-3-pro-image`, and `nano-banana` is an alias for `gemini-2.5-flash-image`. Models with the `:official` suffix (`nano-banana:official`, `nano-banana-2-lite:official`, `nano-banana-2:official`, `nano-banana-pro:official`) are provided through official channels, offering better image quality and stability, with different billing. */
+  model?: "nano-banana" | "nano-banana-2-lite" | "nano-banana-2" | "nano-banana-pro" | "nano-banana:official" | "nano-banana-2-lite:official" | "nano-banana-2:official" | "nano-banana-pro:official";
+  /** Link to the image that needs to be edited. It can be an accessible http or https URL, or a Base64 encoded image string in the format `data:image/png;base64,iVBORw0KG...`. Each image must not exceed 10MB in size. This parameter is required when `action` is `edit`. */
+  imageUrls?: string[];
+  /** Resolution of generated images. Supported values are `1K`, `2K`, `4K`, with a default of `1K`. If this parameter is specified, images will be generated at the specified resolution regardless of whether the `action` is `generate` or `edit` (smaller reference images can be redrawn at a higher resolution); if not specified, the default value of `1K` will be used. `nano-banana` and `nano-banana-2-lite` only support `1K`; `2K` / `4K` are only applicable to models that support high resolution. */
+  resolution?: "1K" | "2K" | "4K";
+  /** Aspect ratio for generating images. Supported values are `1:1`, `3:2`, `2:3`, `16:9`, `9:16`, `4:3`, `3:4`. If this parameter is specified, the specified aspect ratio will be used for generation regardless of whether `action` is `generate` or `edit`; if not specified, the default for `action` as `generate` is `1:1`, and for `action` as `edit`, it will automatically adopt the aspect ratio of the first image in `image_urls` to preserve the original composition. Note: In `edit` mode, specifying an aspect ratio that differs significantly from the original image will cause the model to redraw according to the new ratio, which may deviate from the reference image. */
+  aspectRatio?: "1:1" | "3:2" | "2:3" | "16:9" | "9:16" | "4:3" | "3:4";
+  /** Submit asynchronously and poll. Defaults to true. */
+  async?: boolean;
+  /** Wait for completion before returning the handle. */
+  wait?: boolean;
+  pollInterval?: number;
+  maxWait?: number;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+/** nano-banana client. */
+export class NanoBanana {
+  constructor(private transport: Transport) {}
+
+  /** Google Nano Banana image generation and editing API. Supports nano-banana, nano-banana-2, and nano-banana-pro for text-to-image generation and reference-image editing. */
+  async generate(options: NanoBananaGenerateOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["action"] = options.action;
+    body["prompt"] = options.prompt;
+    body["count"] = options.count ?? 1;
+    if (options.model !== undefined) body["model"] = options.model;
+    if (options.imageUrls !== undefined) body["image_urls"] = options.imageUrls;
+    if (options.resolution !== undefined) body["resolution"] = options.resolution;
+    body["aspect_ratio"] = options.aspectRatio ?? "1:1";
+    for (const [key, value] of Object.entries(options)) {
+      if (!["action", "aspectRatio", "async", "callbackUrl", "count", "imageUrls", "maxWait", "model", "pollInterval", "prompt", "resolution", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    body.async = options.async ?? true;
+    const result = (await this.transport.request('POST', "/nano-banana/images", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/nano-banana/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}

package/src/resources/providers/producer.ts

@@ -0,0 +1,182 @@
+/**
+ * Producer (producer) — generated from the platform OpenAPI spec.
+ *
+ * Do not edit by hand: run `python scripts/generate_providers.py`. Parameter
+ * names, types, enums and required-ness all come from the live spec.
+ */
+
+import { Transport } from '../../runtime/transport';
+import { TaskHandle } from '../../runtime/tasks';
+
+
+function taskId(result: Record<string, unknown>): string {
+  if (typeof result?.task_id === 'string') return result.task_id;
+  const data = result?.data as Record<string, unknown> | undefined;
+  if (data && typeof data.task_id === 'string') return data.task_id;
+  return typeof result?.id === 'string' ? result.id : '';
+}
+
+export interface ProducerUploadOptions {
+  /** The CDN address for the custom audio files to be uploaded. */
+  audioUrl: string;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+export interface ProducerGenerateOptions {
+  /** Reference audio ID. */
+  audioId: string;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+export interface ProducerWavOptions {
+  /** Reference audio ID. */
+  audioId: string;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+export interface ProducerProducerAudiosOptions {
+  /** Lyrics content for generating audio. */
+  lyric: string;
+  /** Types of audio generation operations. Supported values include `generate` (generate based on prompts), `cover` (cover song), `extend` (continue writing), `variation` (variant), `swap_vocals` (replace vocals), `swap_instrumentals` (replace instrumentals), `replace_section` (replace section), `stems` (separate tracks). */
+  action: "generate" | "cover" | "extend" | "variation" | "swap_vocals" | "swap_instrumentals" | "replace_section" | "stems";
+  /** Prompts for generating audio should not exceed 200 characters in length. */
+  prompt: string;
+  /** Random seed used for audio generation. */
+  seed?: string;
+  /** The model used for generating music is `FUZZ-2.0` by default. */
+  model?: "FUZZ-2.0 Pro" | "FUZZ-2.0" | "FUZZ-2.0 Raw" | "FUZZ-1.1 Pro" | "FUZZ-1.0 Pro" | "FUZZ-1.0" | "FUZZ-1.1" | "FUZZ-0.8";
+  /** Title used for generating songs. */
+  title?: string;
+  /** Is it a custom mode? If `true`, the audio will be generated based on the `lyric`; otherwise, it will be generated based on the `prompt`. */
+  custom?: boolean;
+  /** The unique ID of the reference song. */
+  audioId?: string;
+  /** The degree of uniqueness of style can be selected between 0 and 1, with a default value of 0.5. */
+  weirdness?: number;
+  /** Specify the time point (in seconds) from which to continue writing the song. */
+  continueAt?: number;
+  /** If `true`, the generated audio will only contain the accompaniment, without vocal lyrics. */
+  instrumental?: boolean;
+  /** The impact intensity of the audio prompt words can be selected between 0.2 and 1, with a default value of 0.5. */
+  soundStrength?: number;
+  /** The degree of influence of lyrics on audio generation can be selected between 0 and 1, with a default value of 0.5. */
+  lyricsStrength?: number;
+  /** Replace the end time point of the segment (seconds). */
+  replaceSectionEnd?: number;
+  /** Replace the starting time point of the segment (seconds). */
+  replaceSectionStart?: number;
+  /** Submit asynchronously and poll. Defaults to true. */
+  async?: boolean;
+  /** Wait for completion before returning the handle. */
+  wait?: boolean;
+  pollInterval?: number;
+  maxWait?: number;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+export interface ProducerLyricsOptions {
+  /** Prompts for generating lyrics. */
+  prompt: Record<string, unknown>;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+/** producer client. */
+export class Producer {
+  constructor(private transport: Transport) {}
+
+  /** Producer reference audio upload API, upload audio to get an audio_id for generation. */
+  async upload(options: ProducerUploadOptions): Promise<Record<string, unknown>> {
+    const body: Record<string, unknown> = {};
+    body["audio_url"] = options.audioUrl;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "audioUrl", "callbackUrl", "maxWait", "pollInterval", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    return (await this.transport.request('POST', "/producer/upload", { json: body })) as Record<string, unknown>;
+  }
+
+  /** AceData Producer MP4 retrieval API. Pass an audio_id to receive an MP4 video download link with cover art. */
+  async generate(options: ProducerGenerateOptions): Promise<Record<string, unknown>> {
+    const body: Record<string, unknown> = {};
+    body["audio_id"] = options.audioId;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "audioId", "callbackUrl", "maxWait", "pollInterval", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    return (await this.transport.request('POST', "/producer/videos", { json: body })) as Record<string, unknown>;
+  }
+
+  /** AceData Producer WAV (lossless) retrieval API. Pass an audio_id to receive a WAV-format download link. */
+  async wav(options: ProducerWavOptions): Promise<Record<string, unknown>> {
+    const body: Record<string, unknown> = {};
+    body["audio_id"] = options.audioId;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "audioId", "callbackUrl", "maxWait", "pollInterval", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    return (await this.transport.request('POST', "/producer/wav", { json: body })) as Record<string, unknown>;
+  }
+
+  /** Producer AI music generation API, generates 1 song per request. */
+  async producer_audios(options: ProducerProducerAudiosOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["lyric"] = options.lyric;
+    body["action"] = options.action;
+    body["prompt"] = options.prompt;
+    if (options.seed !== undefined) body["seed"] = options.seed;
+    if (options.model !== undefined) body["model"] = options.model;
+    if (options.title !== undefined) body["title"] = options.title;
+    if (options.custom !== undefined) body["custom"] = options.custom;
+    if (options.audioId !== undefined) body["audio_id"] = options.audioId;
+    body["weirdness"] = options.weirdness ?? false;
+    body["continue_at"] = options.continueAt ?? false;
+    body["instrumental"] = options.instrumental ?? false;
+    body["sound_strength"] = options.soundStrength ?? false;
+    body["lyrics_strength"] = options.lyricsStrength ?? false;
+    body["replace_section_end"] = options.replaceSectionEnd ?? false;
+    body["replace_section_start"] = options.replaceSectionStart ?? false;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["action", "async", "audioId", "callbackUrl", "continueAt", "custom", "instrumental", "lyric", "lyricsStrength", "maxWait", "model", "pollInterval", "prompt", "replaceSectionEnd", "replaceSectionStart", "seed", "soundStrength", "title", "wait", "weirdness"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    body.async = options.async ?? true;
+    const result = (await this.transport.request('POST', "/producer/audios", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/producer/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+  /** Producer AI lyrics generation API, input a prompt to generate lyrics. */
+  async lyrics(options: ProducerLyricsOptions): Promise<Record<string, unknown>> {
+    const body: Record<string, unknown> = {};
+    body["prompt"] = options.prompt;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "callbackUrl", "maxWait", "pollInterval", "prompt", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    return (await this.transport.request('POST', "/producer/lyrics", { json: body })) as Record<string, unknown>;
+  }
+
+}

package/src/resources/providers/seedance.ts

@@ -0,0 +1,89 @@
+/**
+ * Seedance (seedance) — generated from the platform OpenAPI spec.
+ *
+ * Do not edit by hand: run `python scripts/generate_providers.py`. Parameter
+ * names, types, enums and required-ness all come from the live spec.
+ */
+
+import { Transport } from '../../runtime/transport';
+import { TaskHandle } from '../../runtime/tasks';
+
+
+function taskId(result: Record<string, unknown>): string {
+  if (typeof result?.task_id === 'string') return result.task_id;
+  const data = result?.data as Record<string, unknown> | undefined;
+  if (data && typeof data.task_id === 'string') return data.task_id;
+  return typeof result?.id === 'string' ? result.id : '';
+}
+
+export interface SeedanceGenerateOptions {
+  /** Model ID for video generation */
+  model: "doubao-seedance-1-0-pro-250528" | "doubao-seedance-1-0-pro-fast-251015" | "doubao-seedance-1-5-pro-251215" | "doubao-seedance-1-0-lite-t2v-250428" | "doubao-seedance-1-0-lite-i2v-250428" | "doubao-seedance-2-0-260128" | "doubao-seedance-2-0-fast-260128" | "doubao-seedance-2-0-mini-260615";
+  /** Input content for video generation. Each entry must include one of `text`, `image_url`, `audio_url`, or `video_url` corresponding to the `type`. The meaning of other fields and whether they are required depends on the value of `type`. */
+  content: unknown[];
+  /** The random seed used for reproducible generation has a value range from -1 to 4294967295; -1 indicates randomness. */
+  seed?: number;
+  /** Aspect ratio of the generated video */
+  ratio?: "16:9" | "4:3" | "1:1" | "3:4" | "9:16" | "21:9" | "adaptive";
+  /** The frame count for generating a video must meet 25 + 4n (such as 29, 33, 37... 361). Either duration or frames can be specified; if both are specified, frames take priority over duration. */
+  frames?: number;
+  /** The duration of the generated video, in seconds. Either duration or frames can be specified; if both are specified, frames take priority over duration. The duration range varies for each model: Seedance 2.0 series is 4 to 15 seconds or -1, Seedance 1.5 Pro is 4 to 12 seconds or -1, and Seedance 1.0 series is 2 to 12 seconds. -1 indicates automatic duration. */
+  duration?: number;
+  /** Whether to add a watermark to the generated video. */
+  watermark?: boolean;
+  /** Video resolution. The default value depends on the model used: most models default to 720p, while the lite model defaults to 480p. Note that the supported resolutions vary by model: `4k` is only supported by doubao-seedance-2-0 (standard version); doubao-seedance-2-0-fast and doubao-seedance-2-0-mini do not support 1080p and 4k. */
+  resolution?: "480p" | "720p" | "1080p" | "4k";
+  /** Is the camera position fixed during the generation process? */
+  camerafixed?: boolean;
+  /** Whether to generate audio from video. The `doubao-seedance-1-5-pro-251215` and `doubao-seedance-2-0` series models support this parameter, while other models will ignore this parameter. */
+  generateAudio?: boolean;
+  /** Whether to return the last frame of the generated video. */
+  returnLastFrame?: boolean;
+  /** Task timeout threshold, unit in seconds */
+  executionExpiresAfter?: number;
+  /** Submit asynchronously and poll. Defaults to true. */
+  async?: boolean;
+  /** Wait for completion before returning the handle. */
+  wait?: boolean;
+  pollInterval?: number;
+  maxWait?: number;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+/** seedance client. */
+export class Seedance {
+  constructor(private transport: Transport) {}
+
+  /** ByteDance Seedance video generation API. Supports doubao-seedance-1-0-pro-250528, doubao-seedance-1-0-pro-fast-251015, doubao-seedance-1-5-pro-251215, doubao-seedance-1-0-lite-t2v-250428, and doubao-s */
+  async generate(options: SeedanceGenerateOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["model"] = options.model;
+    body["content"] = options.content;
+    if (options.seed !== undefined) body["seed"] = options.seed;
+    body["ratio"] = options.ratio ?? "16:9";
+    if (options.frames !== undefined) body["frames"] = options.frames;
+    if (options.duration !== undefined) body["duration"] = options.duration;
+    if (options.watermark !== undefined) body["watermark"] = options.watermark;
+    if (options.resolution !== undefined) body["resolution"] = options.resolution;
+    if (options.camerafixed !== undefined) body["camerafixed"] = options.camerafixed;
+    body["generate_audio"] = options.generateAudio ?? false;
+    body["return_last_frame"] = options.returnLastFrame ?? false;
+    body["execution_expires_after"] = options.executionExpiresAfter ?? 172800;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "callbackUrl", "camerafixed", "content", "duration", "executionExpiresAfter", "frames", "generateAudio", "maxWait", "model", "pollInterval", "ratio", "resolution", "returnLastFrame", "seed", "wait", "watermark"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    body.async = options.async ?? true;
+    const result = (await this.transport.request('POST', "/seedance/videos", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/seedance/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}