@unityclaw/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,799 @@
+import { AxiosInstance } from 'axios';
+
+/**
+ * UnityClaw SDK Type Definitions
+ * AI-powered API types for image/video generation, media analysis, and more
+ */
+/** Text field item with optional link and mention info */
+interface TextFieldItem {
+    type: string;
+    text: string;
+    link?: string;
+    token?: string;
+    mentionType?: number;
+    name?: string;
+}
+/** URL field item */
+interface UrlFieldItem {
+    text: string;
+    link: string;
+}
+/** Attachment field item from bitable */
+interface AttachmentFieldItem {
+    tmp_url: string;
+    name?: string;
+    type?: string;
+    size?: number;
+}
+/** Label/option field item */
+interface LabelFieldItem {
+    value: string | boolean | number;
+    label: string;
+}
+/** Bitable context */
+interface BitableContext {
+    logID: string;
+    timeZone: string;
+    baseID: string;
+    tableID: string;
+}
+/** Request context */
+interface Context {
+    logID: string;
+    timeZone: string;
+    baseID: string;
+    tableID: string;
+    bitable: BitableContext;
+    tenantKey: string;
+    userID: string;
+    packID: string;
+    extensionID: string;
+    baseSignature: string;
+    baseOwnerID: string;
+    isNeedPayPack?: boolean;
+    hasQuota?: boolean;
+}
+/** Minimal context for SDK usage */
+interface SDKContext {
+    logID: string;
+    timeZone?: string;
+    baseID?: string;
+    tableID?: string;
+    userID?: string;
+}
+/** Standard API response wrapper */
+interface APIResponse<T = unknown> {
+    code: number;
+    msg?: string;
+    data?: T;
+}
+/** Attachment result in API responses */
+interface AttachmentResult {
+    name: string;
+    contentType: 'attachment/url';
+    content: string;
+    /** Local file path after download (only available when downloadAttachments is true) */
+    localPath?: string;
+}
+/** Image generation parameters */
+interface ImageGenParams {
+    prompt: string | TextFieldItem[];
+    attachment?: AttachmentFieldItem[];
+    model?: LabelFieldItem | string;
+    aspect_ratio?: LabelFieldItem | string;
+    size?: LabelFieldItem | string;
+    model_selector?: LabelFieldItem;
+    web_search?: LabelFieldItem;
+    image_count?: LabelFieldItem | number;
+}
+/** Gemini image generation params */
+interface GeminiImageParams {
+    prompt: string | TextFieldItem[];
+    attachment?: AttachmentFieldItem[];
+    model?: LabelFieldItem;
+    aspect_ratio?: LabelFieldItem;
+    size?: LabelFieldItem;
+}
+/** JiMeng image generation params */
+interface JiMengImageParams {
+    prompt: string | TextFieldItem[];
+    attachment?: AttachmentFieldItem[];
+    size: LabelFieldItem;
+    model_selector?: LabelFieldItem;
+    web_search?: LabelFieldItem;
+    image_count?: LabelFieldItem | number;
+    model?: string;
+}
+/** Sora video generation params */
+interface SoraVideoParams {
+    attachment?: AttachmentFieldItem[];
+    prompt?: string | TextFieldItem[];
+    orientation: LabelFieldItem;
+}
+/** Veo video generation params */
+interface VeoVideoParams {
+    prompt?: string | TextFieldItem[];
+    attachment?: AttachmentFieldItem[];
+    first_frame?: AttachmentFieldItem[];
+    last_frame?: AttachmentFieldItem[];
+    aspect_ratio?: LabelFieldItem;
+    resolution?: LabelFieldItem;
+    duration?: LabelFieldItem;
+}
+/** Kling video generation params */
+interface KlingVideoParams {
+    attachment?: AttachmentFieldItem[];
+    prompt?: string | TextFieldItem[];
+    aspect_ratio?: LabelFieldItem;
+    duration?: LabelFieldItem;
+    model?: LabelFieldItem;
+}
+/** JiMeng video generation params */
+interface JiMengVideoParams {
+    action: LabelFieldItem;
+    attachment?: AttachmentFieldItem[];
+    prompt?: string | TextFieldItem[];
+    aspect_ratio: LabelFieldItem;
+}
+/** Doubao video generation params */
+interface DoubaoVideoParams {
+    action?: LabelFieldItem;
+    attachment?: AttachmentFieldItem[];
+    prompt?: string | TextFieldItem[];
+    resolution: LabelFieldItem;
+    ratio: LabelFieldItem;
+    duration?: LabelFieldItem;
+}
+/** Wan video generation params */
+interface WanVideoParams {
+    attachment?: AttachmentFieldItem[];
+    prompt?: string | TextFieldItem[];
+    size?: LabelFieldItem;
+    duration?: LabelFieldItem;
+    model?: LabelFieldItem;
+    shot_type?: LabelFieldItem;
+}
+/** MiniMax video generation params */
+interface MiniMaxVideoParams {
+    attachment?: AttachmentFieldItem[];
+    prompt?: string | TextFieldItem[];
+    size?: LabelFieldItem;
+    duration?: LabelFieldItem;
+    model?: LabelFieldItem;
+}
+/** Document translation params */
+interface DocTranslateParams {
+    attachment: AttachmentFieldItem[];
+    source_language: LabelFieldItem | string;
+    target_language: LabelFieldItem | string;
+}
+/** Document conversion params */
+interface DocConvertParams {
+    attachment?: AttachmentFieldItem[];
+    input_format?: string;
+    output_format?: string;
+}
+/** Media analysis params */
+interface MediaAnalysisParams {
+    url: Array<{
+        tmp_url?: string;
+        link?: string;
+        text?: string;
+        type?: string;
+    }>;
+}
+/** Media analysis result */
+interface MediaAnalysisResult {
+    summary: string;
+    subtitle: string;
+}
+/** OpenClaw shortcut params */
+interface OpenClawShortcutParams {
+    task: string;
+    isolate_session?: LabelFieldItem;
+}
+/** SDK client configuration */
+interface UnityClawClientConfig {
+    /** API Key for authentication (can also set UNITYCLAW_API_KEY env var) */
+    apiKey?: string;
+    /** Base URL (default: https://unityclaw.com, or set UNITYCLAW_BASE_URL env var) */
+    baseUrl?: string;
+    /** Task folder directory (default: ./tasks) */
+    taskDir?: string;
+    /** Request timeout in ms (default: 300000 = 5min) */
+    timeout?: number;
+    /** Whether to download attachments to local (default: true) */
+    downloadAttachments?: boolean;
+    /** Custom context overrides */
+    context?: Partial<SDKContext>;
+}
+/** Task execution log */
+interface TaskLog {
+    timestamp: string;
+    level: 'info' | 'error' | 'warn';
+    message: string;
+    data?: unknown;
+}
+/** Task execution result */
+interface TaskResult<T = unknown> {
+    taskId: string;
+    success: boolean;
+    response: T;
+    duration: number;
+    taskFolder: string;
+    logs: TaskLog[];
+    attachments: string[];
+}
+/** Make all properties optional recursively */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/** Extract value from LabelFieldItem or return primitive */
+type LabelValue<T extends LabelFieldItem | string | number | boolean | undefined> = T extends LabelFieldItem ? T['value'] : T;
+/** Union type for text input (string or TextFieldItem array) */
+type TextInput = string | TextFieldItem[];
+
+/**
+ * Task Folder Manager
+ * Creates timestamped folders for each execution, downloads attachments, and logs execution
+ */
+
+/** Task folder manager options */
+interface TaskFolderOptions {
+    /** Base directory for task folders */
+    taskDir: string;
+    /** Whether to download attachments */
+    downloadAttachments: boolean;
+}
+/** Active task folder context */
+interface TaskFolderContext {
+    taskId: string;
+    folderPath: string;
+    attachmentsPath: string;
+    logsPath: string;
+    startTime: number;
+    logs: TaskLog[];
+    downloadedFiles: string[];
+}
+/**
+ * Creates and manages task folders for SDK executions
+ */
+declare class TaskFolderManager {
+    private options;
+    constructor(options: TaskFolderOptions);
+    /**
+     * Create a new task folder with timestamp and unique ID
+     */
+    createTaskFolder(): Promise<TaskFolderContext>;
+    /**
+     * Log a message to the task folder
+     */
+    log(ctx: TaskFolderContext, level: TaskLog['level'], message: string, data?: unknown): Promise<void>;
+    /**
+     * Download an attachment from URL to local folder
+     * Important: Downloads attachments to avoid tmp_url expiration
+     */
+    downloadAttachment(ctx: TaskFolderContext, attachment: AttachmentFieldItem): Promise<string | undefined>;
+    /**
+     * Download multiple attachments
+     */
+    downloadAttachments(ctx: TaskFolderContext, attachments: AttachmentFieldItem[]): Promise<string[]>;
+    /**
+     * Write request details to task folder
+     */
+    writeRequest(ctx: TaskFolderContext, endpoint: string, params: unknown, context: unknown): Promise<void>;
+    /**
+     * Write response details to task folder
+     */
+    writeResponse(ctx: TaskFolderContext, response: unknown): Promise<void>;
+    /**
+     * Finalize task folder and return result
+     */
+    finalizeTaskFolder<T>(ctx: TaskFolderContext, response: T, success: boolean): Promise<TaskResult<T>>;
+    /**
+     * Clean up old task folders (optional utility)
+     */
+    cleanOldFolders(maxAge: number): Promise<number>;
+}
+
+/**
+ * Image Generation APIs
+ * Handles Gemini and JiMeng image generation endpoints
+ */
+
+/** Gemini image generation parameters */
+interface GeminiImageRequestParams {
+    prompt: string | TextFieldItem[];
+    attachment?: GeminiImageParams['attachment'];
+    model?: GeminiImageParams['model'];
+    aspect_ratio?: GeminiImageParams['aspect_ratio'];
+    size?: GeminiImageParams['size'];
+}
+/** JiMeng image generation parameters */
+interface JiMengImageRequestParams {
+    prompt: string | TextFieldItem[];
+    attachment?: JiMengImageParams['attachment'];
+    size: LabelFieldItem | string;
+    model_selector?: JiMengImageParams['model_selector'];
+    web_search?: JiMengImageParams['web_search'];
+    image_count?: JiMengImageParams['image_count'];
+    model?: string;
+}
+/**
+ * Image API module
+ */
+declare class ImageAPI {
+    private client;
+    constructor(client: UnityClawClient);
+    /**
+     * Generate image using Gemini API
+     * @see /api/gemini/image
+     *
+     * @example
+     * ```typescript
+     * const result = await client.image.gemini({
+     *   prompt: 'A beautiful sunset over mountains',
+     *   size: { value: '2K', label: '2K' }
+     * });
+     * ```
+     */
+    gemini(params: GeminiImageRequestParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate image using Gemini API v2
+     * @see /api/gemini/image/v2
+     */
+    geminiV2(params: GeminiImageRequestParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate image using JiMeng (Doubao) API
+     * @see /api/jimeng/image
+     *
+     * @example
+     * ```typescript
+     * const result = await client.image.jimeng({
+     *   prompt: '一只可爱的猫咪',
+     *   size: { value: '1024x1024', label: '1:1' }
+     * });
+     * ```
+     */
+    jimeng(params: JiMengImageRequestParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate image using JiMeng V3 API
+     * @see /api/jimeng/image/v3
+     */
+    jimengV3(params: JiMengImageRequestParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Compress image
+     * @see /api/image/compress
+     */
+    compress(params: {
+        attachment: Array<{
+            tmp_url: string;
+            name?: string;
+            type?: string;
+        }>;
+        quality?: number;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+}
+
+/**
+ * Video Generation APIs
+ * Handles Sora, Veo, Kling, JiMeng, Doubao, Wan, MiniMax video generation endpoints
+ */
+
+/**
+ * Video API module
+ */
+declare class VideoAPI {
+    private client;
+    constructor(client: UnityClawClient);
+    /**
+     * Generate video using Sora API
+     * @see /api/sora/video
+     *
+     * @example
+     * ```typescript
+     * const result = await client.video.sora({
+     *   prompt: 'A cat playing piano',
+     *   orientation: { value: 'landscape', label: 'Landscape' }
+     * });
+     * ```
+     */
+    sora(params: {
+        attachment?: SoraVideoParams['attachment'];
+        prompt?: string | TextFieldItem[];
+        orientation: LabelFieldItem | string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using Sora Stable API
+     * @see /api/sora/video/stable
+     */
+    soraStable(params: {
+        attachment?: Array<{
+            tmp_url: string;
+            name?: string;
+            type?: string;
+        }>;
+        prompt?: string | TextFieldItem[];
+        size?: LabelFieldItem | string;
+        seconds?: LabelFieldItem | string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using Veo API
+     * @see /api/veo/video
+     *
+     * @example
+     * ```typescript
+     * const result = await client.video.veo({
+     *   prompt: 'A beautiful sunset over the ocean',
+     *   aspect_ratio: { value: '16:9', label: '16:9' },
+     *   duration: { value: '8', label: '8s' }
+     * });
+     * ```
+     */
+    veo(params: {
+        prompt?: string | TextFieldItem[];
+        attachment?: VeoVideoParams['attachment'];
+        first_frame?: VeoVideoParams['first_frame'];
+        last_frame?: VeoVideoParams['last_frame'];
+        aspect_ratio?: LabelFieldItem | string;
+        resolution?: LabelFieldItem | string;
+        duration?: LabelFieldItem | string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using Kling API
+     * @see /api/kling/video
+     *
+     * @example
+     * ```typescript
+     * const result = await client.video.kling({
+     *   prompt: 'A dog running in the park',
+     *   aspect_ratio: { value: '16:9', label: '16:9' },
+     *   duration: { value: '5', label: '5s' },
+     *   model: { value: 'kling-v1', label: 'V1' }
+     * });
+     * ```
+     */
+    kling(params: {
+        attachment?: KlingVideoParams['attachment'];
+        prompt?: string | TextFieldItem[];
+        aspect_ratio?: LabelFieldItem | string;
+        duration?: LabelFieldItem | string;
+        model?: LabelFieldItem | string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using JiMeng API
+     * @see /api/jimeng/video
+     *
+     * @example
+     * ```typescript
+     * const result = await client.video.jimeng({
+     *   action: { value: 't2v', label: 'Text to Video' },
+     *   prompt: 'A beautiful landscape',
+     *   aspect_ratio: { value: '16:9', label: '16:9' }
+     * });
+     * ```
+     */
+    jimeng(params: {
+        action: LabelFieldItem | string;
+        attachment?: JiMengVideoParams['attachment'];
+        prompt?: string | TextFieldItem[];
+        aspect_ratio: LabelFieldItem | string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using Doubao API
+     * @see /api/doubao/video
+     *
+     * @example
+     * ```typescript
+     * const result = await client.video.doubao({
+     *   prompt: 'A cinematic drone shot of mountains',
+     *   resolution: { value: '1080p', label: '1080p' },
+     *   ratio: { value: '16:9', label: '16:9' }
+     * });
+     * ```
+     */
+    doubao(params: {
+        action?: LabelFieldItem | string;
+        attachment?: DoubaoVideoParams['attachment'];
+        prompt?: string | TextFieldItem[];
+        resolution: LabelFieldItem | string;
+        ratio: LabelFieldItem | string;
+        duration?: LabelFieldItem | string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using Wan API (Alibaba)
+     * @see /api/wan/video
+     *
+     * @example
+     * ```typescript
+     * const result = await client.video.wan({
+     *   prompt: 'A futuristic city at night',
+     *   size: { value: '1280*720', label: '720p' },
+     *   duration: { value: '5', label: '5s' },
+     *   model: { value: 'wan2.6-t2v', label: 'Wan 2.6' }
+     * });
+     * ```
+     */
+    wan(params: {
+        attachment?: WanVideoParams['attachment'];
+        prompt?: string | TextFieldItem[];
+        size?: LabelFieldItem | string;
+        duration?: LabelFieldItem | string;
+        model?: LabelFieldItem | string;
+        shot_type?: LabelFieldItem | string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using MiniMax API
+     * @see /api/minimax/video
+     *
+     * @example
+     * ```typescript
+     * const result = await client.video.minimax({
+     *   prompt: 'A person walking through a forest',
+     *   size: { value: '1360*768', label: '768p' },
+     *   model: { value: 'MiniMax-Hailuo-2.3', label: 'Hailuo 2.3' }
+     * });
+     * ```
+     */
+    minimax(params: {
+        attachment?: MiniMaxVideoParams['attachment'];
+        prompt?: string | TextFieldItem[];
+        size?: LabelFieldItem | string;
+        duration?: LabelFieldItem | string;
+        model?: LabelFieldItem | string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+}
+
+/**
+ * Document Processing APIs
+ * Handles document translation and conversion endpoints
+ */
+
+/**
+ * Document API module
+ */
+declare class DocumentAPI {
+    private client;
+    constructor(client: UnityClawClient);
+    /**
+     * Translate document
+     * @see /api/doc/translate
+     *
+     * @example
+     * ```typescript
+     * const result = await client.document.translate({
+     *   attachment: [{ tmp_url: 'https://...', name: 'document.pdf' }],
+     *   source_language: { value: 'en', label: 'English' },
+     *   target_language: { value: 'zh', label: 'Chinese' }
+     * });
+     * ```
+     */
+    translate(params: {
+        attachment: DocTranslateParams['attachment'];
+        source_language: LabelFieldItem | string;
+        target_language: LabelFieldItem | string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Convert image to Word document
+     * @see /api/doc_convert/image2word
+     */
+    image2Word(params: {
+        attachment: DocConvertParams['attachment'];
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Convert image to PowerPoint
+     * @see /api/doc_convert/image2ppt
+     */
+    image2Ppt(params: {
+        attachment: DocConvertParams['attachment'];
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Convert image to Excel
+     * @see /api/doc_convert/image2excel
+     */
+    image2Excel(params: {
+        attachment: DocConvertParams['attachment'];
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Convert image to PDF
+     * @see /api/doc_convert/image2pdf
+     */
+    image2Pdf(params: {
+        attachment: DocConvertParams['attachment'];
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Convert PDF to Word document
+     * @see /api/doc_convert/pdf2word
+     */
+    pdf2Word(params: {
+        attachment: DocConvertParams['attachment'];
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Convert PDF to PowerPoint
+     * @see /api/doc_convert/pdf2ppt
+     */
+    pdf2Ppt(params: {
+        attachment: DocConvertParams['attachment'];
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Convert PDF to Excel
+     * @see /api/doc_convert/pdf2excel
+     */
+    pdf2Excel(params: {
+        attachment: DocConvertParams['attachment'];
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Convert PDF to image
+     * @see /api/doc_convert/pdf2image
+     */
+    pdf2Image(params: {
+        attachment: DocConvertParams['attachment'];
+    }): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generic document conversion
+     * @see /api/doc_convert/image
+     * @see /api/doc_convert/pdf
+     */
+    convert(params: {
+        attachment: DocConvertParams['attachment'];
+        input_format?: string;
+        output_format: string;
+    }): Promise<APIResponse<AttachmentResult[]>>;
+}
+
+/**
+ * Media Analysis APIs
+ * Handles video/audio analysis endpoints
+ */
+
+/**
+ * Media API module
+ */
+declare class MediaAPI {
+    private client;
+    constructor(client: UnityClawClient);
+    /**
+     * Analyze media (video/audio) from URL or file
+     * @see /api/media_analysis
+     *
+     * @example
+     * ```typescript
+     * // Analyze from URL
+     * const result = await client.media.analyze({
+     *   url: [{ link: 'https://youtube.com/watch?v=...' }]
+     * });
+     *
+     * // Analyze from uploaded file
+     * const result = await client.media.analyze({
+     *   url: [{ tmp_url: 'https://...', type: 'video/mp4', name: 'video.mp4' }]
+     * });
+     * ```
+     */
+    analyze(params: MediaAnalysisParams): Promise<APIResponse<MediaAnalysisResult>>;
+    /**
+     * Analyze video file directly
+     * @see /api/video_analysis (internal)
+     *
+     * @example
+     * ```typescript
+     * const result = await client.media.analyzeVideo({
+     *   file: { tmp_url: 'https://...', type: 'video/mp4', name: 'video.mp4' },
+     *   prompt: 'Summarize this video'
+     * });
+     * ```
+     */
+    analyzeVideo(params: {
+        file: {
+            tmp_url: string;
+            type?: string;
+            name?: string;
+            size?: number;
+        };
+        prompt?: string;
+    }): Promise<APIResponse<MediaAnalysisResult>>;
+    /**
+     * Analyze social media video (TikTok, YouTube, etc.)
+     * @see /api/media_analysis
+     *
+     * @example
+     * ```typescript
+     * const result = await client.media.analyzeSocialVideo({
+     *   url: 'https://www.tiktok.com/@user/video/123456'
+     * });
+     * ```
+     */
+    analyzeSocialVideo(params: {
+        url: string;
+    }): Promise<APIResponse<MediaAnalysisResult>>;
+}
+
+/**
+ * UnityClaw SDK Client
+ * Main client class for interacting with UnityClaw API
+ */
+
+/**
+ * UnityClaw SDK Client
+ *
+ * AI-powered API client for image/video generation, media analysis, and more.
+ * Each execution creates a local task folder, downloads attachments,
+ * and records execution logs.
+ *
+ * @example
+ * ```typescript
+ * const client = new UnityClawClient({ apiKey: 'your-api-key' });
+ *
+ * // Generate image
+ * const result = await client.image.gemini({
+ *   prompt: 'A beautiful sunset over mountains'
+ * });
+ * ```
+ */
+declare class UnityClawClient {
+    private readonly config;
+    private readonly httpClient;
+    private readonly taskFolderManager;
+    readonly image: ImageAPI;
+    readonly video: VideoAPI;
+    readonly document: DocumentAPI;
+    readonly media: MediaAPI;
+    constructor(config?: UnityClawClientConfig);
+    /**
+     * Get the underlying HTTP client for custom requests
+     */
+    getHttpClient(): AxiosInstance;
+    /**
+     * Get the task folder manager
+     */
+    getTaskFolderManager(): TaskFolderManager;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Required<UnityClawClientConfig>;
+    /**
+     * Build context object from config defaults
+     */
+    private buildContext;
+    /**
+     * Make a request to the UnityClaw API
+     * This is the core method that handles task folder creation, logging, and error handling
+     */
+    request<T = unknown>(endpoint: string, params: Record<string, unknown>, contextOverrides?: Partial<SDKContext>): Promise<TaskResult<APIResponse<T>>>;
+    /**
+     * Generate image using Gemini API
+     * @deprecated Use client.image.gemini() instead
+     */
+    generateImage(params: GeminiImageParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate image using JiMeng API
+     * @deprecated Use client.image.jimeng() instead
+     */
+    generateJiMengImage(params: JiMengImageParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using Sora API
+     * @deprecated Use client.video.sora() instead
+     */
+    generateSoraVideo(params: SoraVideoParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using Veo API
+     * @deprecated Use client.video.veo() instead
+     */
+    generateVeoVideo(params: VeoVideoParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Generate video using Kling API
+     * @deprecated Use client.video.kling() instead
+     */
+    generateKlingVideo(params: KlingVideoParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Translate document
+     * @deprecated Use client.document.translate() instead
+     */
+    translateDocument(params: DocTranslateParams): Promise<APIResponse<AttachmentResult[]>>;
+    /**
+     * Analyze media (video/audio from URL)
+     * @deprecated Use client.media.analyze() instead
+     */
+    analyzeMedia(params: MediaAnalysisParams): Promise<APIResponse<MediaAnalysisResult>>;
+}
+
+export { type APIResponse, type AttachmentFieldItem, type AttachmentResult, type BitableContext, type Context, type DeepPartial, type DocConvertParams, type DocTranslateParams, DocumentAPI, type DoubaoVideoParams, type GeminiImageParams, ImageAPI, type ImageGenParams, type JiMengImageParams, type JiMengVideoParams, type KlingVideoParams, type LabelFieldItem, type LabelValue, MediaAPI, type MediaAnalysisParams, type MediaAnalysisResult, type MiniMaxVideoParams, type OpenClawShortcutParams, type SDKContext, type SoraVideoParams, type TaskFolderContext, TaskFolderManager, type TaskFolderOptions, type TaskLog, type TaskResult, type TextFieldItem, type TextInput, UnityClawClient, type UnityClawClientConfig, type UrlFieldItem, type VeoVideoParams, VideoAPI, type WanVideoParams };