@acedatacloud/sdk 2026.722.0 → 2026.727.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/sdk",
-  "version": "2026.722.0",
+  "version": "2026.727.1",
   "description": "Official TypeScript SDK for AceDataCloud — AI-powered data services",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/client.ts

@@ -18,6 +18,7 @@ import { Kling } from './resources/kling';
 import { WebExtrator } from './resources/webextrator';
 import { Face } from './resources/face';
 import { ShortUrl } from './resources/shorturl';
+import { attachProviders } from './resources/providers';
 
 export interface AceDataCloudOptions {
   apiToken?: string;
@@ -81,5 +82,7 @@ export class AceDataCloud {
     this.webextrator = new WebExtrator(this.transport);
     this.face = new Face(this.transport);
     this.shorturl = new ShortUrl(this.transport);
+    // Provider axis: one namespace per service, generated from the specs.
+    attachProviders(this as unknown as Record<string, unknown>, this.transport);
   }
 }

package/src/resources/providers/digitalhuman.ts

@@ -0,0 +1,123 @@
+/**
+ * Digitalhuman (digitalhuman) — 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 DigitalhumanGenerateOptions {
+  /** Public URL of the source face video (preferred). One of video_url/image_url required. */
+  videoUrl: string;
+  /** Spoken text -> TTS (requires voice_id). */
+  text?: string;
+  /** Audio tempo multiplier. */
+  speed?: number;
+  /** Diffusion steps (LatentSync). */
+  steps?: number;
+  /** latentsync = quality (default); heygem = fast tier. */
+  engine?: "latentsync" | "heygem";
+  /** Lip-sync strength (LatentSync). Lower loosens sync. */
+  guidance?: number;
+  /** Apply the mouth-seam reduction blend. */
+  seamFix?: boolean;
+  /** A cloned voice from POST /digital-human/voices. */
+  voiceId?: string;
+  /** Public URL of the driving audio (.wav/.mp3/.m4a). OR supply text(+voice_id). */
+  audioUrl?: string;
+  /** Public URL of a source face photo (photo-driven path). */
+  imageUrl?: string;
+  resolution?: "720p" | "540p";
+  /** 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 DigitalhumanVoicesOptions {
+  /** Public URL of a clean 10-20s voice sample. */
+  audioUrl: string;
+  lang?: "zh" | "en";
+  /** Optional label. */
+  name?: 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;
+}
+
+/** digitalhuman client. */
+export class Digitalhuman {
+  constructor(private transport: Transport) {}
+
+  /** Digital Human video generation API — turn a portrait plus audio or text into a talking-head video. */
+  async generate(options: DigitalhumanGenerateOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["video_url"] = options.videoUrl;
+    body["text"] = options.text ?? "\u5927\u5bb6\u597d\uff0c\u8fd9\u662f\u79bb\u7ebf\u751f\u6210\u7684\u6570\u5b57\u4eba\u3002";
+    body["speed"] = options.speed ?? 1.0;
+    body["steps"] = options.steps ?? 40;
+    body["engine"] = options.engine ?? "latentsync";
+    body["guidance"] = options.guidance ?? 2.0;
+    body["seam_fix"] = options.seamFix ?? true;
+    if (options.voiceId !== undefined) body["voice_id"] = options.voiceId;
+    if (options.audioUrl !== undefined) body["audio_url"] = options.audioUrl;
+    if (options.imageUrl !== undefined) body["image_url"] = options.imageUrl;
+    body["resolution"] = options.resolution ?? "720p";
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "audioUrl", "callbackUrl", "engine", "guidance", "imageUrl", "maxWait", "pollInterval", "resolution", "seamFix", "speed", "steps", "text", "videoUrl", "voiceId", "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', "/digital-human/videos", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/digital-human/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+  /** Digital Human voice-clone API — upload an audio sample to clone a custom voice for speech synthesis. */
+  async voices(options: DigitalhumanVoicesOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["audio_url"] = options.audioUrl;
+    body["lang"] = options.lang ?? "zh";
+    if (options.name !== undefined) body["name"] = options.name;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "audioUrl", "callbackUrl", "lang", "maxWait", "name", "pollInterval", "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', "/digital-human/voices", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/digital-human/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}

package/src/resources/providers/dreamina.ts

@@ -0,0 +1,68 @@
+/**
+ * Dreamina (dreamina) — 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 DreaminaGenerateOptions {
+  /** Public URL for audio (mp3/wav). The character will lip-sync to it, and it is recommended that the duration be controlled within 60 seconds. */
+  audioUrl: string;
+  /** Public URL of portrait images. Clear frontal face effects are best. */
+  imageUrl: string;
+  /** The model being used is OmniHuman 1.5. */
+  model?: "omnihuman-1.5";
+  /** Optional text prompts for guiding expressions, emotions, stability, and style. */
+  prompt?: string;
+  /** Optional subject mask URL (from object detection) to specify and drive a particular person in a multi-person image. */
+  maskUrl?: 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;
+}
+
+/** dreamina client. */
+export class Dreamina {
+  constructor(private transport: Transport) {}
+
+  /** Audio-driven talking-photo digital human video generation (OmniHuman 1.5) */
+  async generate(options: DreaminaGenerateOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["audio_url"] = options.audioUrl;
+    body["image_url"] = options.imageUrl;
+    body["model"] = options.model ?? "omnihuman-1.5";
+    if (options.prompt !== undefined) body["prompt"] = options.prompt;
+    if (options.maskUrl !== undefined) body["mask_url"] = options.maskUrl;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "audioUrl", "callbackUrl", "imageUrl", "maskUrl", "maxWait", "model", "pollInterval", "prompt", "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', "/dreamina/videos", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/dreamina/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}

package/src/resources/providers/fish.ts

@@ -0,0 +1,146 @@
+/**
+ * Fish (fish) — 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 FishGenerateOptions {
+  /** Text content to be synthesized. Required, must be a non-empty string. */
+  text: string;
+  /** Top-p nucleus sampling parameter, controls output diversity. */
+  topP?: number;
+  /** Output audio format, default is `mp3`. */
+  format?: "mp3" | "wav" | "pcm" | "opus";
+  /** Delay mode. The upstream rejects null values, and defaults to `normal` when omitted. */
+  latency?: "normal" | "balanced";
+  /** Rhythm coverage parameters, forwarded as is to upstream (such as speech rate, volume, etc.). */
+  prosody?: Record<string, unknown>;
+  /** Is the input text subjected to text normalization processing by the upstream? */
+  normalize?: boolean;
+  /** Inline reference audio samples will be forwarded upstream as is, for zero-shot voice cloning. */
+  references?: unknown[];
+  /** MP3 bitrate when `format=mp3`. */
+  mp3Bitrate?: number;
+  /** Output the audio sampling rate (e.g., 16000, 22050, 44100). */
+  sampleRate?: number;
+  /** Sampling temperature (0.0–1.0). The higher the value, the more diverse the output; the lower the value, the more stable and consistent it is. */
+  temperature?: number;
+  /** The chunk length passed to the upstream synthesizer. */
+  chunkLength?: number;
+  /** Opus bitrate when `format=opus`. */
+  opusBitrate?: number;
+  /** Voice model ID (single speaker). A string array can also be passed in multi-speaker scenarios. */
+  referenceId?: string;
+  /** Maximum number of new tokens generated. */
+  maxNewTokens?: number;
+  /** Minimum block length. */
+  minChunkLength?: number;
+  /** The repetition penalty coefficient applied during the generation process. */
+  repetitionPenalty?: 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 FishModelOptions {
+  /** Name of the voice model. */
+  title: string;
+  /** The HTTP(S) URL of the audio file for cloning must be a single URL string. This interface does not support multipart/binary file uploads. */
+  voices: string;
+  /** Tags used for retrieval in public repositories (optional). */
+  tags?: string[];
+  /** Reference text corresponding to the audio sample (optional). */
+  texts?: string[];
+  /** The visibility of the model is set to `private` by default. */
+  visibility?: "public" | "private";
+  /** HTTP(S) URL of the voice model cover image (optional). */
+  coverImage?: string;
+  /** Description of the voice model (optional). */
+  description?: string;
+  /** If it is `true`, the upstream service will generate a sample voice after the training is completed. */
+  generateSample?: boolean;
+  /** If it is `true`, the upstream service will perform quality enhancement processing on the audio samples before training. */
+  enhanceAudioQuality?: boolean;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+/** fish client. */
+export class Fish {
+  constructor(private transport: Transport) {}
+
+  /** Fish Audio text-to-speech API — convert text into natural speech using a chosen voice model. */
+  async generate(options: FishGenerateOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["text"] = options.text;
+    if (options.topP !== undefined) body["top_p"] = options.topP;
+    if (options.format !== undefined) body["format"] = options.format;
+    if (options.latency !== undefined) body["latency"] = options.latency;
+    if (options.prosody !== undefined) body["prosody"] = options.prosody;
+    if (options.normalize !== undefined) body["normalize"] = options.normalize;
+    if (options.references !== undefined) body["references"] = options.references;
+    if (options.mp3Bitrate !== undefined) body["mp3_bitrate"] = options.mp3Bitrate;
+    if (options.sampleRate !== undefined) body["sample_rate"] = options.sampleRate;
+    if (options.temperature !== undefined) body["temperature"] = options.temperature;
+    if (options.chunkLength !== undefined) body["chunk_length"] = options.chunkLength;
+    if (options.opusBitrate !== undefined) body["opus_bitrate"] = options.opusBitrate;
+    body["reference_id"] = options.referenceId ?? "d7900c21663f485ab63ebdb7e5905036";
+    if (options.maxNewTokens !== undefined) body["max_new_tokens"] = options.maxNewTokens;
+    if (options.minChunkLength !== undefined) body["min_chunk_length"] = options.minChunkLength;
+    if (options.repetitionPenalty !== undefined) body["repetition_penalty"] = options.repetitionPenalty;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "callbackUrl", "chunkLength", "format", "latency", "maxNewTokens", "maxWait", "minChunkLength", "mp3Bitrate", "normalize", "opusBitrate", "pollInterval", "prosody", "referenceId", "references", "repetitionPenalty", "sampleRate", "temperature", "text", "topP", "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', "/fish/tts", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/fish/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+  /** Fish Audio model creation API — upload reference audio to create a custom voice-clone model. */
+  async model(options: FishModelOptions): Promise<Record<string, unknown>> {
+    const body: Record<string, unknown> = {};
+    body["title"] = options.title;
+    body["voices"] = options.voices;
+    if (options.tags !== undefined) body["tags"] = options.tags;
+    if (options.texts !== undefined) body["texts"] = options.texts;
+    if (options.visibility !== undefined) body["visibility"] = options.visibility;
+    if (options.coverImage !== undefined) body["cover_image"] = options.coverImage;
+    if (options.description !== undefined) body["description"] = options.description;
+    if (options.generateSample !== undefined) body["generate_sample"] = options.generateSample;
+    if (options.enhanceAudioQuality !== undefined) body["enhance_audio_quality"] = options.enhanceAudioQuality;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "callbackUrl", "coverImage", "description", "enhanceAudioQuality", "generateSample", "maxWait", "pollInterval", "tags", "texts", "title", "visibility", "voices", "wait"].includes(key) && value !== undefined) {
+        body[key] = value;
+      }
+    }
+    if (options.callbackUrl !== undefined) body.callback_url = options.callbackUrl;
+    return (await this.transport.request('POST', "/fish/model", { json: body })) as Record<string, unknown>;
+  }
+
+}

package/src/resources/providers/flux.ts

@@ -0,0 +1,71 @@
+/**
+ * Flux (flux) — 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 FluxGenerateOptions {
+  /** Types of operations for generating images. If it is `generate`, a new image will be created based on the prompt; if it is `edit`, the original image will be edited according to the prompt and `image_url`. */
+  action: "generate" | "edit";
+  /** Prompts for generating images. */
+  prompt: string;
+  /** Image size specifications. */
+  size?: string;
+  /** Number of generated images. */
+  count?: number;
+  /** Model used for generating images. */
+  model?: "flux-dev" | "flux-pro" | "flux-kontext-pro" | "flux-kontext-max" | "flux-2-flex" | "flux-2-pro" | "flux-2-max" | "flux-2-klein";
+  /** Link to the original image that needs editing. */
+  imageUrl?: 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;
+}
+
+/** flux client. */
+export class Flux {
+  constructor(private transport: Transport) {}
+
+  /** Flux AI image generation API, generates 1 image per request. */
+  async generate(options: FluxGenerateOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["action"] = options.action;
+    body["prompt"] = options.prompt;
+    body["size"] = options.size ?? "1024x1024";
+    if (options.count !== undefined) body["count"] = options.count;
+    if (options.model !== undefined) body["model"] = options.model;
+    if (options.imageUrl !== undefined) body["image_url"] = options.imageUrl;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["action", "async", "callbackUrl", "count", "imageUrl", "maxWait", "model", "pollInterval", "prompt", "size", "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', "/flux/images", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/flux/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}

package/src/resources/providers/hailuo.ts

@@ -0,0 +1,65 @@
+/**
+ * Hailuo (hailuo) — 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 HailuoGenerateOptions {
+  /** The operation type for video generation. When set to `generate`, it will generate a video based on the prompt. */
+  action: "generate";
+  /** The model used for generating videos has a default value of `minimax-t2v`. */
+  model?: "minimax-i2v" | "minimax-t2v" | "minimax-i2v-director";
+  /** Prompts for generating videos. */
+  prompt?: string;
+  /** You can specify the URL of the first frame image to generate a video from the image. */
+  firstImageUrl?: 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;
+}
+
+/** hailuo client. */
+export class Hailuo {
+  constructor(private transport: Transport) {}
+
+  /** Minimax Hailuo AI video generation API. Supports minimax-t2v for text-to-video, minimax-i2v for image-to-video, and minimax-i2v-director for director mode with camera/movement instructions. */
+  async generate(options: HailuoGenerateOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["action"] = options.action;
+    if (options.model !== undefined) body["model"] = options.model;
+    body["prompt"] = options.prompt ?? "\u706b\u6c14";
+    if (options.firstImageUrl !== undefined) body["first_image_url"] = options.firstImageUrl;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["action", "async", "callbackUrl", "firstImageUrl", "maxWait", "model", "pollInterval", "prompt", "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', "/hailuo/videos", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/hailuo/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}

package/src/resources/providers/happyhorse.ts

@@ -0,0 +1,89 @@
+/**
+ * Happyhorse (happyhorse) — 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 HappyhorseGenerateOptions {
+  /** Random seed, range 0–2147483647. */
+  seed?: number;
+  /** HappyHorse model name. Different actions only support the corresponding model family. */
+  model?: "happyhorse-1.0-t2v" | "happyhorse-1.1-t2v" | "happyhorse-1.0-i2v" | "happyhorse-1.1-i2v" | "happyhorse-1.0-r2v" | "happyhorse-1.1-r2v" | "happyhorse-1.0-video-edit";
+  /** Output video aspect ratio. Text-to-video and reference image-to-video support this parameter; the first frame image-to-video will follow the aspect ratio of the first frame image. */
+  ratio?: "16:9" | "9:16" | "1:1" | "4:3" | "3:4";
+  /** Operation types. `generate` is for generating video from text, `image_to_video` is for generating video from the first frame image, `reference_to_video` is for generating video from reference images, and `video_edit` is for video editing based on video and reference images. */
+  action?: "generate" | "image_to_video" | "reference_to_video" | "video_edit";
+  /** Text prompt words. Text-to-video, reference image to video, and video editing scenarios are required. */
+  prompt?: string;
+  /** Output video duration (seconds), value range 3–15. The output duration of `video_edit` is determined by the input video. */
+  duration?: number;
+  /** The input image URL for the first frame of the video. Only used by `image_to_video`. */
+  imageUrl?: string;
+  /** URL of the video to be edited. For `video_edit` use only. */
+  videoUrl?: string;
+  /** Whether to add the HappyHorse watermark. Default is off. */
+  watermark?: boolean;
+  /** Reference image URL array. `reference_to_video` supports 1–9 images, `video_edit` supports 0–5 images. */
+  imageUrls?: string[];
+  /** Output video resolution, optional 720P or 1080P. */
+  resolution?: "720P" | "1080P";
+  /** Audio strategy for video editing. `auto` is determined by the model, `origin` retains the original audio of the input video. */
+  audioSetting?: "auto" | "origin";
+  /** 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;
+}
+
+/** happyhorse client. */
+export class Happyhorse {
+  constructor(private transport: Transport) {}
+
+  /** Call /happyhorse/videos. */
+  async generate(options: HappyhorseGenerateOptions = {}): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    if (options.seed !== undefined) body["seed"] = options.seed;
+    body["model"] = options.model ?? "happyhorse-1.1-t2v";
+    body["ratio"] = options.ratio ?? "16:9";
+    body["action"] = options.action ?? "generate";
+    body["prompt"] = options.prompt ?? "A cinematic white horse lifts its head, the mane moves gently in the sunrise wind, slow camera push in, warm film lighting";
+    body["duration"] = options.duration ?? 5;
+    body["image_url"] = options.imageUrl ?? "https://cdn.acedata.cloud/b1c82e4937.png";
+    body["video_url"] = options.videoUrl ?? "https://platform2.cdn.acedata.cloud/happyhorse/27837f92-d1c1-4db4-ad9a-4e6e81d9f6c1.mp4";
+    body["watermark"] = options.watermark ?? false;
+    if (options.imageUrls !== undefined) body["image_urls"] = options.imageUrls;
+    body["resolution"] = options.resolution ?? "1080P";
+    body["audio_setting"] = options.audioSetting ?? "auto";
+    for (const [key, value] of Object.entries(options)) {
+      if (!["action", "async", "audioSetting", "callbackUrl", "duration", "imageUrl", "imageUrls", "maxWait", "model", "pollInterval", "prompt", "ratio", "resolution", "seed", "videoUrl", "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', "/happyhorse/videos", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/happyhorse/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}

package/src/resources/providers/index.ts

@@ -0,0 +1,53 @@
+/** Provider-axis clients, generated from the platform OpenAPI specs. */
+
+export { Digitalhuman } from './digitalhuman';
+export { Dreamina } from './dreamina';
+export { Fish } from './fish';
+export { Flux } from './flux';
+export { Hailuo } from './hailuo';
+export { Happyhorse } from './happyhorse';
+export { Localization } from './localization';
+export { Luma } from './luma';
+export { Maestro } from './maestro';
+export { NanoBanana } from './nano-banana';
+export { Producer } from './producer';
+export { Seedance } from './seedance';
+export { Seedream } from './seedream';
+export { Suno } from './suno';
+export { Wan } from './wan';
+
+import { Transport } from '../../runtime/transport';
+import { Digitalhuman } from './digitalhuman';
+import { Dreamina } from './dreamina';
+import { Fish } from './fish';
+import { Flux } from './flux';
+import { Hailuo } from './hailuo';
+import { Happyhorse } from './happyhorse';
+import { Localization } from './localization';
+import { Luma } from './luma';
+import { Maestro } from './maestro';
+import { NanoBanana } from './nano-banana';
+import { Producer } from './producer';
+import { Seedance } from './seedance';
+import { Seedream } from './seedream';
+import { Suno } from './suno';
+import { Wan } from './wan';
+
+/** Bind every generated provider client onto `client`. */
+export function attachProviders(client: Record<string, unknown>, transport: Transport): void {
+  client.digitalhuman = new Digitalhuman(transport);
+  client.dreamina = new Dreamina(transport);
+  client.fish = new Fish(transport);
+  client.flux = new Flux(transport);
+  client.hailuo = new Hailuo(transport);
+  client.happyhorse = new Happyhorse(transport);
+  client.localization = new Localization(transport);
+  client.luma = new Luma(transport);
+  client.maestro = new Maestro(transport);
+  client.nanobanana = new NanoBanana(transport);
+  client.producer = new Producer(transport);
+  client.seedance = new Seedance(transport);
+  client.seedream = new Seedream(transport);
+  client.suno = new Suno(transport);
+  client.wan = new Wan(transport);
+}