@acedatacloud/sdk 2026.805.0 → 2026.809.0

package/package.json

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

package/src/client.ts

@@ -4,6 +4,7 @@ import { Transport, TransportOptions } from './runtime/transport';
 import type { PaymentHandler } from './runtime/payment';
 import { AiChat } from './resources/aichat';
 import { Chat } from './resources/chat';
+import { Captcha } from './resources/captcha';
 import { Images } from './resources/images';
 import { Audio } from './resources/audio';
 import { Video } from './resources/video';
@@ -38,6 +39,7 @@ export interface AceDataCloudOptions {
 export class AceDataCloud {
   readonly aichat: AiChat;
   readonly chat: Chat;
+  readonly captcha: Captcha;
   readonly images: Images;
   readonly audio: Audio;
   readonly video: Video;
@@ -68,6 +70,7 @@ export class AceDataCloud {
 
     this.aichat = new AiChat(this.transport);
     this.chat = new Chat(this.transport);
+    this.captcha = new Captcha(this.transport);
     this.images = new Images(this.transport);
     this.audio = new Audio(this.transport);
     this.video = new Video(this.transport);

package/src/resources/captcha.ts

@@ -0,0 +1,66 @@
+/** Captcha resources (`/captcha/*`). */
+
+import { Transport } from '../runtime/transport';
+
+class Recognition {
+  constructor(private transport: Transport) {}
+
+  hcaptcha(opts: {
+    queries?: string[];
+    question?: string;
+    async?: boolean;
+    [key: string]: unknown;
+  } = {}): Promise<Record<string, unknown>> {
+    const { queries, question, ...rest } = opts;
+    const body: Record<string, unknown> = { ...rest };
+    if (queries !== undefined) body.queries = queries;
+    if (question !== undefined) body.question = question;
+    return this.transport.request('POST', '/captcha/recognition/hcaptcha', { json: body });
+  }
+}
+
+class Token {
+  constructor(private transport: Transport) {}
+
+  hcaptcha(opts: {
+    websiteKey: string;
+    websiteUrl: string;
+    rqdata?: string;
+    proxy?: string;
+    async?: boolean;
+    [key: string]: unknown;
+  }): Promise<Record<string, unknown>> {
+    const { websiteKey, websiteUrl, rqdata, proxy, ...rest } = opts;
+    const body: Record<string, unknown> = {
+      website_key: websiteKey,
+      website_url: websiteUrl,
+      ...rest,
+    };
+    if (rqdata !== undefined) body.rqdata = rqdata;
+    if (proxy !== undefined) body.proxy = proxy;
+    return this.transport.request('POST', '/captcha/token/hcaptcha', { json: body });
+  }
+}
+
+class Tasks {
+  constructor(private transport: Transport) {}
+
+  retrieve(opts: { taskId: string; [key: string]: unknown }): Promise<Record<string, unknown>> {
+    const { taskId, ...rest } = opts;
+    return this.transport.request('POST', '/captcha/tasks', {
+      json: { task_id: taskId, ...rest },
+    });
+  }
+}
+
+export class Captcha {
+  readonly recognition: Recognition;
+  readonly token: Token;
+  readonly tasks: Tasks;
+
+  constructor(transport: Transport) {
+    this.recognition = new Recognition(transport);
+    this.token = new Token(transport);
+    this.tasks = new Tasks(transport);
+  }
+}

package/src/resources/providers/index.ts

@@ -9,6 +9,7 @@ export { Happyhorse } from './happyhorse';
 export { Localization } from './localization';
 export { Luma } from './luma';
 export { Maestro } from './maestro';
+export { Minimax } from './minimax';
 export { NanoBanana } from './nano-banana';
 export { Producer } from './producer';
 export { Seedance } from './seedance';
@@ -26,6 +27,7 @@ import { Happyhorse } from './happyhorse';
 import { Localization } from './localization';
 import { Luma } from './luma';
 import { Maestro } from './maestro';
+import { Minimax } from './minimax';
 import { NanoBanana } from './nano-banana';
 import { Producer } from './producer';
 import { Seedance } from './seedance';
@@ -44,6 +46,7 @@ export function attachProviders(client: Record<string, unknown>, transport: Tran
   client.localization = new Localization(transport);
   client.luma = new Luma(transport);
   client.maestro = new Maestro(transport);
+  client.minimax = new Minimax(transport);
   client.nanobanana = new NanoBanana(transport);
   client.producer = new Producer(transport);
   client.seedance = new Seedance(transport);

package/src/resources/providers/minimax.ts

@@ -0,0 +1,66 @@
+/**
+ * Minimax (minimax) — 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 MinimaxGenerateOptions {
+  /** Minimax Videos Model */
+  model: "MiniMax-H3";
+  /** Minimax Videos Content */
+  content: Array<Record<string, unknown>>;
+  /** Minimax Videos Resolution */
+  resolution: "768P" | "2K";
+  /** Minimax Videos Duration */
+  duration: number;
+  /** Minimax Videos Ratio */
+  ratio?: "adaptive" | "21:9" | "16:9" | "4:3" | "1:1" | "3:4" | "9:16";
+  async?: boolean;
+  wait?: boolean;
+  pollInterval?: number;
+  maxWait?: number;
+  callbackUrl?: string;
+  /** Any parameter added upstream before the SDK is regenerated. */
+  [key: string]: unknown;
+}
+
+/** minimax client. */
+export class Minimax {
+  constructor(private transport: Transport) {}
+
+  /** Minimax Videos */
+  async generate(options: MinimaxGenerateOptions): Promise<TaskHandle> {
+    const body: Record<string, unknown> = {};
+    body["model"] = options.model;
+    body["content"] = options.content;
+    body["resolution"] = options.resolution;
+    body["duration"] = options.duration;
+    if (options.ratio !== undefined) body["ratio"] = options.ratio;
+    for (const [key, value] of Object.entries(options)) {
+      if (!["async", "callbackUrl", "content", "duration", "maxWait", "model", "pollInterval", "ratio", "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', "/minimax/videos", { json: body })) as Record<string, unknown>;
+    const handle = new TaskHandle(taskId(result), "/minimax/tasks", this.transport, result);
+    if (options.wait) {
+      await handle.wait({ pollInterval: options.pollInterval, maxWait: options.maxWait });
+    }
+    return handle;
+  }
+
+}

package/src/resources/tasks.ts

@@ -20,6 +20,7 @@ const SERVICE_TASK_ENDPOINTS: Record<string, string> = {
   pika: '/pika/tasks',
   pixverse: '/pixverse/tasks',
   webextrator: '/webextrator/tasks',
+  captcha: '/captcha/tasks',
 };
 
 export class Tasks {