@fuserstudio/sdk 0.0.0-stage → 0.0.1

package/index.d.ts

@@ -0,0 +1,2607 @@
+//#region src/generated/types.gen.d.ts
+type ApiError = {
+  /**
+   * The HTTP error kind, e.g. NOT_FOUND or CONFLICT.
+   */
+  code: string;
+  message: string;
+  /**
+   * Which conflict a 409 is: stale_revision, idempotency_key_reused or canvas_not_editable.
+   */
+  reason?: string;
+  issues?: Array<{
+    message: string;
+    path: string;
+  }>;
+};
+type CanvasListData = {
+  body?: never;
+  path?: never;
+  query?: {
+    query?: string;
+    workspaceId?: string | 'personal';
+    limit?: number;
+    cursor?: string;
+  };
+  url: '/v1/canvas_list';
+};
+type CanvasListErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type CanvasListResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    canvases: Array<{
+      canvasId: string;
+      title: string;
+      /**
+       * The workspace it is in; null for your personal space.
+       */
+      workspaceId: string | null;
+      updatedAt: string | null;
+      url: string;
+    }>;
+    nextCursor: string | null;
+  };
+};
+type CanvasGetData = {
+  body?: never;
+  path?: never;
+  query: {
+    canvasId: string;
+    cursor?: string;
+    nodeIds?: Array<string>;
+    search?: string;
+  };
+  url: '/v1/canvas_get';
+};
+type CanvasGetErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type CanvasGetResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    canvasId: string;
+    title: string;
+    url: string;
+    revision: number;
+    summary: {
+      nodeCount: number;
+      edgeCount: number;
+      nodesByType: {
+        [key: string]: number;
+      };
+      /**
+       * The box around every node.
+       */
+      bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+      } | null;
+    };
+    nodes: Array<{
+      id: string;
+      type?: string;
+      label?: string;
+      /**
+       * Left edge on the canvas (larger is further right), the same coordinates canvas_edit moveNodes and canvas_arrange take.
+       */
+      x?: number;
+      /**
+       * Top edge; larger is further down.
+       */
+      y?: number;
+      /**
+       * Drawn width.
+       */
+      width?: number;
+      /**
+       * Drawn height.
+       */
+      height?: number;
+      /**
+       * The group node it sits in.
+       */
+      group?: string;
+      in: Array<string>;
+      out: Array<string>;
+      values?: {
+        [key: string]: string;
+      };
+      results?: Array<string>;
+    }>;
+    edges: Array<{
+      from: string;
+      to: string;
+    }>;
+    nextCursor: string | null;
+  };
+};
+type CanvasEditData = {
+  body: {
+    /**
+     * Canvas to edit. Omit it and pass newCanvas to create one.
+     */
+    canvasId?: string;
+    /**
+     * Rename the canvas. With canvasId only; a new canvas takes newCanvas.name. The diff may be empty when this is all you're changing.
+     */
+    title?: string;
+    /**
+     * Create a new canvas with this name and apply the diff to it.
+     */
+    newCanvas?: {
+      name: string;
+      /**
+       * Workspace to create it in, from account_get. Omit for your personal space.
+       */
+      workspaceId?: string;
+    };
+    /**
+     * A fresh random value, such as a UUID, for each new edit; never reuse one from an earlier edit. Resend the same key only when retrying this same edit.
+     */
+    idempotencyKey: string;
+    /**
+     * The revision from your latest canvas_get or canvas_edit. If someone has edited the canvas since, the edit still applies unless it touches nodes they changed; then it is refused, naming them. Results arriving from runs never count.
+     */
+    expectedRevision?: number;
+    diff: {
+      nodes?: Array<{
+        /**
+         * Local id, unique in this diff, referenced by edges.
+         */
+        ref: string;
+        /**
+         * Node type key from the vocabulary.
+         */
+        type: string;
+        /**
+         * Short role-specific display name for this node.
+         */
+        label: string;
+        /**
+         * Literal input values as {id, value} pairs, using allowed input ids. Use an empty array when every input comes from edges.
+         */
+        inputs: Array<{
+          id: string;
+          /**
+           * Literal input value.
+           */
+          value: string | number | boolean | Array<string>;
+        }>;
+      }>;
+      edges?: Array<{
+        /**
+         * Source socket: "ref.outputId" for a new node, or "#nodeId.outputId" for an existing canvas node.
+         */
+        from: string;
+        /**
+         * Target socket: "ref.inputId" for a new node, or "#nodeId.inputId" for an existing canvas node.
+         */
+        to: string;
+      }>;
+      /**
+       * Existing edges to remove before applying the rest of this edit. Both ends must use "#nodeId.socket" refs. Empty array when no standalone disconnection is needed.
+       */
+      disconnectEdges?: Array<{
+        /**
+         * Source socket: "ref.outputId" for a new node, or "#nodeId.outputId" for an existing canvas node.
+         */
+        from: string;
+        /**
+         * Target socket: "ref.inputId" for a new node, or "#nodeId.inputId" for an existing canvas node.
+         */
+        to: string;
+      }>;
+      /**
+       * Input changes on existing canvas nodes (edit mode only). Empty array otherwise.
+       */
+      setInputs?: Array<{
+        /**
+         * Existing canvas node id.
+         */
+        nodeId: string;
+        inputId: string;
+        /**
+         * Literal input value.
+         */
+        value: string | number | boolean | Array<string>;
+      }>;
+      /**
+       * Existing canvas node ids to DELETE (edit mode only — e.g. when replacing a node with a different type). Deleting a node also removes its edges. Empty array otherwise.
+       */
+      deleteNodeIds?: Array<string>;
+      /**
+       * Change how large existing nodes are drawn on the canvas. This is not the output's resolution or aspect ratio, which are node inputs. A media node's height follows its media's shape. Nothing else moves: nodes a bigger node now covers come back in overlaps, and canvas_arrange lays them out again.
+       */
+      resizeNodes?: Array<{
+        /**
+         * An existing node id.
+         */
+        nodeId: string;
+        /**
+         * New width in canvas pixels. Outputs are drawn 320 wide by default.
+         */
+        width: number;
+      }>;
+      /**
+       * Move existing nodes to exact spots. To lay several out in a row, column, grid or along their wiring, use canvas_arrange instead of working out positions.
+       */
+      moveNodes?: Array<{
+        /**
+         * An existing node id.
+         */
+        nodeId: string;
+        /**
+         * New left edge, in canvas_get's coordinates.
+         */
+        x: number;
+        /**
+         * New top edge, in canvas_get's coordinates.
+         */
+        y: number;
+      }>;
+      /**
+       * Rename existing nodes (the name shown on the node). Nothing moves. New nodes take their name from label.
+       */
+      renameNodes?: Array<{
+        /**
+         * An existing node id.
+         */
+        nodeId: string;
+        /**
+         * Its new name.
+         */
+        label: string;
+      }>;
+      /**
+       * Make a labelled group (a frame on the canvas) around nodes, add nodes to an existing group, or recolor one. The frame grows to fit. Lay nodes out first with canvas_arrange if they are spread out. Deleting a group node keeps its members.
+       */
+      groups?: Array<{
+        /**
+         * Name for a new group. Pass this or groupId.
+         */
+        label?: string;
+        /**
+         * An existing group to add the nodes to or recolor.
+         */
+        groupId?: string;
+        /**
+         * Nodes to put in the group where they sit now: existing ids (moved out of any other group) or refs of nodes this edit adds.
+         */
+        nodeIds?: Array<string>;
+        /**
+         * Frame color. gray is the default.
+         */
+        color?: 'gray' | 'purple' | 'mint' | 'sky' | 'tangerine' | 'rose';
+      }>;
+      /**
+       * Take these nodes out of their group, leaving them where they are.
+       */
+      ungroupNodeIds?: Array<string>;
+    };
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/canvas_edit';
+};
+type CanvasEditErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Conflicts with an earlier request; see reason.
+   */
+  409: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type CanvasEditResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    canvasId: string;
+    url: string;
+    revision: number;
+    createdNodeIds: {
+      [key: string]: string;
+    };
+    warnings: Array<string>;
+    /**
+     * Moved or resized nodes that now overlap another node. Lay them out with canvas_arrange, or move them.
+     */
+    overlaps: Array<{
+      nodeId: string;
+      overlapsWith: string;
+    }>;
+    replayed: boolean;
+  };
+};
+type CanvasArrangeData = {
+  body: {
+    canvasId: string;
+    /**
+     * Nodes to arrange, all at the top level or all in the same group. With layout, this order is the placement order.
+     */
+    nodeIds?: Array<string>;
+    /**
+     * Tidy every top-level node on the canvas. Only when the user asked to reorganize the whole canvas: it moves work they placed by hand.
+     */
+    all?: boolean;
+    layout?: {
+      /**
+       * row: left to right. column: top to bottom. grid: rows of `columns`.
+       */
+      mode: 'row' | 'column' | 'grid';
+      /**
+       * Nodes per row for grid; defaults to about the square root of the count.
+       */
+      columns?: number;
+      /**
+       * Space between nodes, in canvas pixels. Default 64.
+       */
+      gap?: number;
+      /**
+       * Top-left corner of the block, in canvas_get's coordinates. It is used as given, even over other nodes.
+       */
+      origin?: {
+        x: number;
+        y: number;
+      };
+    };
+    /**
+     * The revision from your latest canvas_get or canvas_edit; the call is refused only if someone changed these nodes since.
+     */
+    expectedRevision?: number;
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/canvas_arrange';
+};
+type CanvasArrangeErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type CanvasArrangeResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    canvasId: string;
+    url: string;
+    revision: number;
+    arranged: number;
+    moved: number;
+    /**
+     * The arranged block's box; place more work below or beside it.
+     */
+    bounds: {
+      x: number;
+      y: number;
+      width: number;
+      height: number;
+    };
+    /**
+     * Arranged nodes that overlap other nodes, possible with an explicit origin. Arrange again without an origin to clear them.
+     */
+    overlaps: Array<{
+      nodeId: string;
+      overlapsWith: string;
+    }>;
+  };
+};
+type CatalogSearchData = {
+  body?: never;
+  path?: never;
+  query?: {
+    query?: string;
+    category?: 'image' | 'video' | 'text' | 'mesh' | 'primitive';
+  };
+  url: '/v1/catalog_search';
+};
+type CatalogSearchErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type CatalogSearchResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    /**
+     * False when nothing matched the query; nodeTypes then lists everything available.
+     */
+    matched: boolean;
+    note?: string;
+    /**
+     * The node to use for each common job, with the input values to set.
+     */
+    recommended: Array<{
+      job: string;
+      type: string;
+      inputs?: {
+        [key: string]: string;
+      };
+      /**
+       * About what one run costs at its cheapest settings.
+       */
+      credits?: number;
+    }>;
+    nodeTypes: Array<{
+      type: string;
+      category: 'image' | 'video' | 'text' | 'mesh' | 'primitive';
+      purpose: string;
+      inputs: Array<{
+        id: string;
+        kind: 'text' | 'number' | 'boolean' | 'enum' | 'image' | 'video' | 'media';
+        description: string;
+        required?: boolean;
+        multiple?: boolean;
+        values?: Array<string>;
+        min?: number;
+        max?: number;
+        defaultValue?: string | number | boolean;
+      }>;
+      output: string;
+      notes?: Array<string>;
+      /**
+       * About what one run costs at its cheapest settings, per model or variant, cheapest first. Compare these to pick a cheaper model; run_start dryRun gives the exact price on a canvas.
+       */
+      prices?: Array<{
+        variant: string;
+        credits: number;
+        settings: string;
+      }>;
+    }>;
+  };
+};
+type RunStartData = {
+  body: {
+    canvasId: string;
+    /**
+     * Nodes to run, plus whatever they need upstream. Omit to run the whole canvas.
+     */
+    nodeIds?: Array<string>;
+    /**
+     * The most this run may cost; it is refused above it. Required unless dryRun.
+     */
+    maxCredits?: number;
+    /**
+     * A fresh random value, such as a UUID, for each new run; required unless dryRun. Resend the same key only when retrying this same run; the first run is returned instead of starting another.
+     */
+    idempotencyKey?: string;
+    /**
+     * Only price the run and list anything blocking it; nothing starts and nothing is spent.
+     */
+    dryRun?: boolean;
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/run_start';
+};
+type RunStartErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Conflicts with an earlier request; see reason.
+   */
+  409: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type RunStartResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    status: 'quoted';
+    quote: {
+      nodeIds: Array<string>;
+      credits: number;
+      /**
+       * Chat nodes and paid tools, included in credits at a rough guess. The run is charged what they actually cost.
+       */
+      guessedNodeIds: Array<string>;
+      unpricedNodeIds: Array<string>;
+      blockers: Array<{
+        code: 'active_run_exists' | 'compositor_participates' | 'unsupported_node' | 'missing_required_input' | 'dependency_cycle' | 'no_executable_nodes' | 'stale_preflight' | 'expired_preflight' | 'unbuilt_tool' | 'insufficient_credits';
+        nodeId?: string;
+        message: string;
+      }>;
+    };
+    /**
+     * Where Fuser's plans are described, when the plan or credits are why the run is blocked or refused.
+     */
+    plansUrl?: string;
+  } | {
+    status: 'started';
+    runId: string;
+    /**
+     * True when this idempotencyKey had already started the run.
+     */
+    replayed: boolean;
+    quote: {
+      nodeIds: Array<string>;
+      credits: number;
+      /**
+       * Chat nodes and paid tools, included in credits at a rough guess. The run is charged what they actually cost.
+       */
+      guessedNodeIds: Array<string>;
+      unpricedNodeIds: Array<string>;
+      blockers: Array<{
+        code: 'active_run_exists' | 'compositor_participates' | 'unsupported_node' | 'missing_required_input' | 'dependency_cycle' | 'no_executable_nodes' | 'stale_preflight' | 'expired_preflight' | 'unbuilt_tool' | 'insufficient_credits';
+        nodeId?: string;
+        message: string;
+      }>;
+    };
+    run?: {
+      runId: string;
+      status: 'running' | 'completed' | 'failed' | 'cancelled';
+      quotedCredits: number;
+      /**
+       * ISO 8601.
+       */
+      startedAt: string;
+      /**
+       * ISO 8601.
+       */
+      completedAt?: string;
+      nodes: Array<{
+        nodeId: string;
+        type: string | null;
+        status: 'pending' | 'running' | 'succeeded' | 'failed' | 'skipped' | 'cancelled' | 'unknown';
+        error?: string;
+        /**
+         * Links to the node's current results.
+         */
+        outputs: Array<string>;
+        /**
+         * The node's text result (a chat reply, or a tool's text or json), cut at 4,000 characters.
+         */
+        text?: string;
+      }>;
+      /**
+       * Where Fuser's plans are described, when a node failed because the plan doesn't include it.
+       */
+      plansUrl?: string;
+    };
+  } | {
+    status: 'refused';
+    reason: 'blocked' | 'over_budget' | 'insufficient_credits' | 'missing_max_credits' | 'unpriced' | 'start_failed';
+    error: string;
+    quote?: {
+      nodeIds: Array<string>;
+      credits: number;
+      /**
+       * Chat nodes and paid tools, included in credits at a rough guess. The run is charged what they actually cost.
+       */
+      guessedNodeIds: Array<string>;
+      unpricedNodeIds: Array<string>;
+      blockers: Array<{
+        code: 'active_run_exists' | 'compositor_participates' | 'unsupported_node' | 'missing_required_input' | 'dependency_cycle' | 'no_executable_nodes' | 'stale_preflight' | 'expired_preflight' | 'unbuilt_tool' | 'insufficient_credits';
+        nodeId?: string;
+        message: string;
+      }>;
+    };
+    /**
+     * Where Fuser's plans are described, when the plan or credits are why the run is blocked or refused.
+     */
+    plansUrl?: string;
+  };
+};
+type RunGetData = {
+  body?: never;
+  path?: never;
+  query: {
+    canvasId: string;
+    runId: string;
+    waitSeconds?: number;
+  };
+  url: '/v1/run_get';
+};
+type RunGetErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type RunGetResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    runId: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    quotedCredits: number;
+    /**
+     * ISO 8601.
+     */
+    startedAt: string;
+    /**
+     * ISO 8601.
+     */
+    completedAt?: string;
+    nodes: Array<{
+      nodeId: string;
+      type: string | null;
+      status: 'pending' | 'running' | 'succeeded' | 'failed' | 'skipped' | 'cancelled' | 'unknown';
+      error?: string;
+      /**
+       * Links to the node's current results.
+       */
+      outputs: Array<string>;
+      /**
+       * The node's text result (a chat reply, or a tool's text or json), cut at 4,000 characters.
+       */
+      text?: string;
+    }>;
+    /**
+     * Where Fuser's plans are described, when a node failed because the plan doesn't include it.
+     */
+    plansUrl?: string;
+  };
+};
+type RunCancelData = {
+  body: {
+    canvasId: string;
+    runId: string;
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/run_cancel';
+};
+type RunCancelErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type RunCancelResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    cancelled: boolean;
+  };
+};
+type MediaImportData = {
+  body: {
+    canvasId: string;
+    url: string;
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/media_import';
+};
+type MediaImportErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type MediaImportResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    url: string;
+    mimeType: string;
+  };
+};
+type UploadStartData = {
+  body: {
+    /**
+     * Canvas the files belong to.
+     */
+    canvasId: string;
+    /**
+     * Files you can send yourself, up to 50. Leave empty to only get uploadPage for the user.
+     */
+    files?: Array<{
+      /**
+       * The file name, with extension.
+       */
+      fileName: string;
+      /**
+       * MIME type, e.g. image/jpeg.
+       */
+      contentType: string;
+      /**
+       * Size in bytes.
+       */
+      size: number;
+      /**
+       * Base64 SHA-256 of the file, e.g. from `openssl dgst -sha256 -binary FILE | base64`.
+       */
+      sha256: string;
+    }>;
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/upload_start';
+};
+type UploadStartErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type UploadStartResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    /**
+     * Pass to upload_finish.
+     */
+    uploadId: string;
+    /**
+     * A page where the user picks the files in their browser. Give it to them only if you cannot send the files yourself.
+     */
+    uploadPage: string;
+    expiresAt: string;
+    files: Array<{
+      fileName: string;
+      status: 'upload';
+      method: 'PUT';
+      url: string;
+      /**
+       * Send these headers with the file as the body.
+       */
+      headers: {
+        [key: string]: string;
+      };
+    } | {
+      fileName: string;
+      status: 'done';
+      asset: {
+        url: string;
+        mimeType: string;
+      };
+    }>;
+  };
+};
+type UploadFinishData = {
+  body: {
+    uploadId: string;
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/upload_finish';
+};
+type UploadFinishErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type UploadFinishResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    /**
+     * Every file sent so far, in the order given to upload_start, with its link or why it failed. Files the user adds on the upload page follow once they finish there.
+     */
+    files: Array<{
+      url: string;
+      mimeType: string;
+      status: 'done';
+      fileName: string;
+    } | {
+      status: 'failed';
+      fileName: string;
+      error: string;
+    }>;
+  };
+};
+type MediaViewData = {
+  body: {
+    /**
+     * Fuser media links, from run_get results, canvas_get values or media_import.
+     */
+    urls: Array<string>;
+    /**
+     * high shows images at 1024 px instead of 512, for reading small text (up to 8 at a time).
+     */
+    detail?: 'normal' | 'high';
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/media_view';
+};
+type MediaViewErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type MediaViewResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    items: Array<{
+      url: string;
+      kind: 'image' | 'video' | 'audio' | 'mesh' | 'unknown';
+      facts?: {
+        [key: string]: string | number | boolean;
+      };
+      previews: Array<{
+        mimeType: string;
+        /**
+         * Base64 image bytes.
+         */
+        data: string;
+        atSeconds?: number;
+      }>;
+      note?: string;
+    }>;
+  };
+};
+type MediaSearchData = {
+  body: {
+    /**
+     * What you are looking for, in plain words.
+     */
+    query?: string;
+    /**
+     * A mediaId from an earlier result: find ones like it.
+     */
+    similarTo?: string;
+    type?: 'image' | 'video' | 'audio' | 'mesh' | 'all';
+    /**
+     * upload = files you added, generation = made in Fuser.
+     */
+    source?: 'upload' | 'generation' | 'stock' | 'all';
+    /**
+     * Only media on this canvas.
+     */
+    canvasId?: string;
+    /**
+     * Search a workspace's shared library (from account_get) instead of your own.
+     */
+    workspaceId?: string;
+    limit?: number;
+    /**
+     * nextCursor from the previous page, passed back unchanged.
+     */
+    cursor?: string;
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/media_search';
+};
+type MediaSearchErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type MediaSearchResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    assets: Array<{
+      mediaId: string;
+      url: string;
+      type: string | null;
+      title: string | null;
+      description: string | null;
+      createdAt: string | null;
+      canvases: Array<{
+        canvasId: string;
+        title: string;
+      }>;
+    }>;
+    nextCursor: string | null;
+  };
+};
+type MediaExportData = {
+  body: {
+    canvasId: string;
+    /**
+     * Only these nodes. Omit for every node on the canvas.
+     */
+    nodeIds?: Array<string>;
+    /**
+     * results: what the canvas generated. all: also the images and videos placed on it (the user's uploads and references).
+     */
+    include?: 'results' | 'all';
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/media_export';
+};
+type MediaExportErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type MediaExportResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    /**
+     * Opens a download of the zip. Give it to the user.
+     */
+    url: string;
+    expiresAt: string;
+    fileCount: number;
+    files: Array<{
+      name: string;
+      nodeId: string;
+      url: string;
+    }>;
+  };
+};
+type AccountGetData = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: '/v1/account_get';
+};
+type AccountGetErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type AccountGetResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    name: string | null;
+    email: string;
+    personalCredits: number;
+    /**
+     * What the plan allows. Check it before a big build, and when something is refused for the plan, tell the user what the plan doesn't include and share plansUrl.
+     */
+    personalPlan: {
+      name: string;
+      trial: boolean;
+      canvases: {
+        used: number | null;
+        /**
+         * Null when unlimited.
+         */
+        limit: number | null;
+      };
+      nodesPerCanvas: number | null;
+      /**
+       * Whether a whole canvas can run at once.
+       */
+      runAll: boolean;
+      /**
+       * Whether tool_build can write tools.
+       */
+      buildTools: boolean;
+      /**
+       * Whether media_search takes query and similarTo.
+       */
+      searchByMeaning: boolean;
+      /**
+       * Whether you manage this plan; in a workspace only owners and admins do.
+       */
+      managesPlan: boolean;
+      /**
+       * Where Fuser's plans are described.
+       */
+      plansUrl: string;
+    };
+    workspaces: Array<{
+      workspaceId: string;
+      name: string;
+      role: 'owner' | 'admin' | 'member';
+      credits: number;
+      /**
+       * False when the workspace has no active plan or is paused.
+       */
+      canSpend: boolean;
+      /**
+       * Your own cap in this workspace, if one is set.
+       */
+      monthlySpendLimit: {
+        limit: number;
+        remaining: number;
+      } | null;
+      /**
+       * What the plan allows. Check it before a big build, and when something is refused for the plan, tell the user what the plan doesn't include and share plansUrl.
+       */
+      plan: {
+        name: string;
+        trial: boolean;
+        canvases: {
+          used: number | null;
+          /**
+           * Null when unlimited.
+           */
+          limit: number | null;
+        };
+        nodesPerCanvas: number | null;
+        /**
+         * Whether a whole canvas can run at once.
+         */
+        runAll: boolean;
+        /**
+         * Whether tool_build can write tools.
+         */
+        buildTools: boolean;
+        /**
+         * Whether media_search takes query and similarTo.
+         */
+        searchByMeaning: boolean;
+        /**
+         * Whether you manage this plan; in a workspace only owners and admins do.
+         */
+        managesPlan: boolean;
+        /**
+         * Where Fuser's plans are described.
+         */
+        plansUrl: string;
+      };
+    }>;
+  };
+};
+type ToolSearchData = {
+  body?: never;
+  path?: never;
+  query: {
+    canvasId?: string;
+    /**
+     * A few words, e.g. "join videos" or "halftone".
+     */
+    query: string;
+    limit?: number;
+  };
+  url: '/v1/tool_search';
+};
+type ToolSearchErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type ToolSearchResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    tools: Array<{
+      toolId: string;
+      description: string | null;
+      featured: boolean;
+      tool: {
+        title: string;
+        /**
+         * free tools cost nothing to run; paid ones call AI helpers and cost credits per run.
+         */
+        mode: 'free' | 'paid';
+        inputs: Array<{
+          socket: string;
+          kind: 'image' | 'video' | 'audio' | 'mesh' | 'text';
+          many: boolean;
+          required: boolean;
+        }>;
+        controls: Array<{
+          socket: string;
+          label: string;
+          kind: 'slider';
+          default: number;
+          min: number;
+          max: number;
+        } | {
+          socket: string;
+          label: string;
+          kind: 'dropdown';
+          default: string;
+          options: Array<string>;
+        } | {
+          socket: string;
+          label: string;
+          kind: 'switch';
+          default: boolean;
+        }>;
+        outputs: Array<{
+          socket: string;
+          kind: 'image' | 'video' | 'audio' | 'text' | 'json';
+        }>;
+      };
+    }>;
+  };
+};
+type ToolBuildData = {
+  body: {
+    canvasId: string;
+    /**
+     * The Tool node (type UtilityNode).
+     */
+    nodeId: string;
+    /**
+     * What the tool does, in plain words, with its inputs and the controls worth having: "join the videos in order into one clip, with a crossfade length slider". On a built tool, the change to make.
+     */
+    prompt?: string;
+    /**
+     * A saved tool from tool_search to place instead.
+     */
+    toolId?: string;
+    /**
+     * Wait up to this long (at most 45) for the build. Builds usually take 30–90 seconds; call again without prompt to keep waiting.
+     */
+    waitSeconds?: number;
+  };
+  path?: never;
+  query?: never;
+  url: '/v1/tool_build';
+};
+type ToolBuildErrors = {
+  /**
+   * The input is invalid.
+   */
+  400: ApiError;
+  /**
+   * No valid API key.
+   */
+  401: ApiError;
+  /**
+   * The key or user can't do this.
+   */
+  403: ApiError;
+  /**
+   * The canvas, run, node or upload was not found.
+   */
+  404: ApiError;
+  /**
+   * Too many requests; wait Retry-After seconds.
+   */
+  429: ApiError;
+  /**
+   * Something went wrong on our side.
+   */
+  500: ApiError;
+};
+type ToolBuildResponses = {
+  /**
+   * Successful response
+   */
+  200: {
+    status: 'building';
+    revision: number;
+  } | {
+    status: 'built';
+    /**
+     * The built tool. Wire inputs and set controls by these socket names.
+     */
+    tool: {
+      title: string;
+      /**
+       * free tools cost nothing to run; paid ones call AI helpers and cost credits per run.
+       */
+      mode: 'free' | 'paid';
+      inputs: Array<{
+        socket: string;
+        kind: 'image' | 'video' | 'audio' | 'mesh' | 'text';
+        many: boolean;
+        required: boolean;
+      }>;
+      controls: Array<{
+        socket: string;
+        label: string;
+        kind: 'slider';
+        default: number;
+        min: number;
+        max: number;
+      } | {
+        socket: string;
+        label: string;
+        kind: 'dropdown';
+        default: string;
+        options: Array<string>;
+      } | {
+        socket: string;
+        label: string;
+        kind: 'switch';
+        default: boolean;
+      }>;
+      outputs: Array<{
+        socket: string;
+        kind: 'image' | 'video' | 'audio' | 'text' | 'json';
+      }>;
+    };
+    revision: number;
+  } | {
+    status: 'failed' | 'refused';
+    error: string;
+    /**
+     * The tool as it was before this build, if any.
+     */
+    tool?: {
+      title: string;
+      /**
+       * free tools cost nothing to run; paid ones call AI helpers and cost credits per run.
+       */
+      mode: 'free' | 'paid';
+      inputs: Array<{
+        socket: string;
+        kind: 'image' | 'video' | 'audio' | 'mesh' | 'text';
+        many: boolean;
+        required: boolean;
+      }>;
+      controls: Array<{
+        socket: string;
+        label: string;
+        kind: 'slider';
+        default: number;
+        min: number;
+        max: number;
+      } | {
+        socket: string;
+        label: string;
+        kind: 'dropdown';
+        default: string;
+        options: Array<string>;
+      } | {
+        socket: string;
+        label: string;
+        kind: 'switch';
+        default: boolean;
+      }>;
+      outputs: Array<{
+        socket: string;
+        kind: 'image' | 'video' | 'audio' | 'text' | 'json';
+      }>;
+    };
+    revision: number;
+  } | {
+    status: 'unbuilt';
+    revision: number;
+  };
+};
+//#endregion
+//#region src/errors.d.ts
+interface FuserErrorDetails {
+  /** The tool that failed, e.g. `run_start`. */
+  tool: string;
+  status?: number;
+  /** The API's error kind, e.g. `NOT_FOUND`. */
+  code?: string;
+  /** Which conflict a 409 is, e.g. `stale_revision`. */
+  reason?: string;
+  issues?: ApiError['issues'];
+  requestId?: string;
+  retryAfterMs?: number;
+  body?: unknown;
+  cause?: unknown;
+}
+/** Every error the SDK throws. Subclasses say what went wrong. */
+export declare class FuserError extends Error {
+  name: string;
+  readonly tool: string;
+  readonly status: number | undefined;
+  readonly code: string | undefined;
+  readonly reason: string | undefined;
+  readonly issues: ApiError['issues'];
+  readonly requestId: string | undefined;
+  readonly retryAfterMs: number | undefined;
+  readonly body: unknown;
+  constructor(message: string, details: FuserErrorDetails);
+}
+export declare class BadRequestError extends FuserError {
+  name: string;
+}
+export declare class AuthenticationError extends FuserError {
+  name: string;
+}
+export declare class PermissionDeniedError extends FuserError {
+  name: string;
+}
+export declare class NotFoundError extends FuserError {
+  name: string;
+}
+export declare class ConflictError extends FuserError {
+  name: string;
+}
+export declare class RateLimitError extends FuserError {
+  name: string;
+}
+export declare class InternalServerError extends FuserError {
+  name: string;
+}
+export declare class ConnectionError extends FuserError {
+  name: string;
+}
+export declare class TimeoutError extends FuserError {
+  name: string;
+}
+/** `run.start(...).wait()` on a run Fuser refused to start. */
+export declare class RunRefusedError extends FuserError {
+  name: string;
+}
+//#endregion
+//#region src/generated/core/auth.gen.d.ts
+type AuthToken = string | undefined;
+interface Auth {
+  /**
+   * Which part of the request do we use to send the auth?
+   *
+   * @default 'header'
+   */
+  in?: 'header' | 'query' | 'cookie';
+  /**
+   * A unique identifier for the security scheme.
+   *
+   * Defined only when there are multiple security schemes whose `Auth`
+   * shape would otherwise be identical.
+   */
+  key?: string;
+  /**
+   * Header or query parameter name.
+   *
+   * @default 'Authorization'
+   */
+  name?: string;
+  scheme?: 'basic' | 'bearer';
+  type: 'apiKey' | 'http';
+}
+//#endregion
+//#region src/generated/core/pathSerializer.gen.d.ts
+interface SerializerOptions<T> {
+  /**
+   * @default true
+   */
+  explode: boolean;
+  style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+//#endregion
+//#region src/generated/core/bodySerializer.gen.d.ts
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+  allowReserved?: boolean;
+  array?: Partial<SerializerOptions<ArrayStyle>>;
+  object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+  /**
+   * Per-parameter serialization overrides. When provided, these settings
+   * override the global array/object settings for specific parameter names.
+   */
+  parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+//#endregion
+//#region src/generated/core/types.gen.d.ts
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+  /**
+   * Returns the final request URL.
+   */
+  buildUrl: BuildUrlFn;
+  getConfig: () => Config;
+  request: RequestFn;
+  setConfig: (config: Config) => Config;
+} & { [K in HttpMethod]: MethodFn; } & ([SseFn] extends [never] ? {
+  sse?: never;
+} : {
+  sse: { [K in HttpMethod]: SseFn; };
+});
+interface Config$1 {
+  /**
+   * Auth token or a function returning auth token. The resolved value will be
+   * added to the request payload as defined by its `security` array.
+   */
+  auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+  /**
+   * A function for serializing request body parameter. By default,
+   * {@link JSON.stringify()} will be used.
+   */
+  bodySerializer?: BodySerializer | null;
+  /**
+   * An object containing any HTTP headers that you want to pre-populate your
+   * `Headers` object with.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+   */
+  headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+  /**
+   * The request method.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+   */
+  method?: Uppercase<HttpMethod>;
+  /**
+   * A function for serializing request query parameters. By default, arrays
+   * will be exploded in form style, objects will be exploded in deepObject
+   * style, and reserved characters are percent-encoded.
+   *
+   * This method will have no effect if the native `paramsSerializer()` Axios
+   * API function is used.
+   *
+   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+   */
+  querySerializer?: QuerySerializer | QuerySerializerOptions;
+  /**
+   * A function validating request data. This is useful if you want to ensure
+   * the request conforms to the desired shape, so it can be safely sent to
+   * the server.
+   */
+  requestValidator?: (data: unknown) => Promise<unknown>;
+  /**
+   * A function transforming response data before it's returned. This is useful
+   * for post-processing data, e.g., converting ISO strings into Date objects.
+   */
+  responseTransformer?: (data: unknown) => Promise<unknown>;
+  /**
+   * A function validating response data. This is useful if you want to ensure
+   * the response conforms to the desired shape, so it can be safely passed to
+   * the transformers and returned to the user.
+   */
+  responseValidator?: (data: unknown) => Promise<unknown>;
+}
+/**
+ * Arbitrary metadata passed through the `meta` request option.
+ */
+interface ClientMeta {}
+//#endregion
+//#region src/generated/core/serverSentEvents.gen.d.ts
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+  /**
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: typeof fetch;
+  /**
+   * Implementing clients can call request interceptors inside this hook.
+   */
+  onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+  /**
+   * Callback invoked when a network or parsing error occurs during streaming.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @param error The error that occurred.
+   */
+  onSseError?: (error: unknown) => void;
+  /**
+   * Callback invoked when an event is streamed from the server.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @param event Event streamed from the server.
+   * @returns Nothing (void).
+   */
+  onSseEvent?: (event: StreamEvent<TData>) => void;
+  serializedBody?: RequestInit['body'];
+  /**
+   * Default retry delay in milliseconds.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @default 3000
+   */
+  sseDefaultRetryDelay?: number;
+  /**
+   * Maximum number of retry attempts before giving up.
+   */
+  sseMaxRetryAttempts?: number;
+  /**
+   * Maximum retry delay in milliseconds.
+   *
+   * Applies only when exponential backoff is used.
+   *
+   * This option applies only if the endpoint returns a stream of events.
+   *
+   * @default 30000
+   */
+  sseMaxRetryDelay?: number;
+  /**
+   * Optional sleep function for retry backoff.
+   *
+   * Defaults to using `setTimeout`.
+   */
+  sseSleepFn?: (ms: number) => Promise<void>;
+  url: string;
+};
+interface StreamEvent<TData = unknown> {
+  data: TData;
+  event?: string;
+  id?: string;
+  retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+  stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+//#endregion
+//#region src/generated/client/utils.gen.d.ts
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err,
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined,
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+  fns: Array<Interceptor | null>;
+  clear(): void;
+  eject(id: number | Interceptor): void;
+  exists(id: number | Interceptor): boolean;
+  getInterceptorIndex(id: number | Interceptor): number;
+  update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+  use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+  error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+  request: Interceptors<ReqInterceptor<Req, Options>>;
+  response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+//#endregion
+//#region src/generated/client/types.gen.d.ts
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseUrl?: T['baseUrl'];
+  /**
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: typeof fetch;
+  /**
+   * Please don't use the Fetch client for Next.js applications. The `next`
+   * options won't have any effect.
+   *
+   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+   */
+  next?: never;
+  /**
+   * Return the response data parsed in a specified format. By default, `auto`
+   * will infer the appropriate method from the `Content-Type` response header.
+   * You can override this behavior with any of the {@link Body} methods.
+   * Select `stream` if you don't want to parse response data at all.
+   *
+   * @default 'auto'
+   */
+  parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+  /**
+   * Should we return only data or multiple fields (data, error, response, etc.)?
+   *
+   * @default 'fields'
+   */
+  responseStyle?: ResponseStyle;
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError'];
+}
+interface RequestOptions$1<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+  responseStyle: TResponseStyle;
+  throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+  /**
+   * Any body that you want to add to your request.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+   */
+  body?: unknown;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  /**
+   * Security mechanism(s) to use for the request.
+   */
+  security?: ReadonlyArray<Auth>;
+  url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions$1<unknown, TResponseStyle, ThrowOnError, Url> {
+  headers: Headers;
+  serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+  data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+  request: Request;
+  response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+  data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+  error: undefined;
+} | {
+  data: undefined;
+  error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+  /** request may be undefined, because error may be from building the request object itself */
+  request?: Request;
+  /** response may be undefined, because error may be from building the request object itself or from a network error */
+  response?: Response;
+}>;
+interface ClientOptions {
+  baseUrl?: string;
+  responseStyle?: ResponseStyle;
+  throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions$1<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions$1<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions$1<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions$1<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+  body?: unknown;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  url: string;
+}>(options: TData & Options$1<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+  url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions$1<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+declare namespace sdk_gen_d_exports {
+  export { Options, accountGet, canvasArrange, canvasEdit, canvasGet, canvasList, catalogSearch, mediaExport, mediaImport, mediaSearch, mediaView, runCancel, runGet, runStart, toolBuild, toolSearch, uploadFinish, uploadStart };
+}
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<TData, ThrowOnError, TResponse> & {
+  /**
+   * You can provide a client instance returned by `createClient()` instead of
+   * individual options. This might be also useful if you want to implement a
+   * custom client.
+   */
+  client?: Client;
+  /**
+   * You can pass arbitrary values through the `meta` object. This can be
+   * used to access values that aren't defined as part of the SDK function.
+   */
+  meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+/**
+ * List canvases
+ *
+ * Canvases you can open, most recently edited first, with a link to each. Reuse one only when the user points to it; put new work on a new canvas, and never present results that were already there as new.
+ */
+declare const canvasList: <ThrowOnError extends boolean = false>(options?: Options<CanvasListData, ThrowOnError>) => RequestResult<CanvasListResponses, CanvasListErrors, ThrowOnError>;
+/**
+ * Read a canvas
+ *
+ * A compact view of a canvas: a summary, then pages of nodes (id, type, label, socket keys, literal values, result links) and their edges. On a big canvas, find nodes with search or read specific ones with nodeIds instead of paging through everything.
+ */
+declare const canvasGet: <ThrowOnError extends boolean = false>(options: Options<CanvasGetData, ThrowOnError>) => RequestResult<CanvasGetResponses, CanvasGetErrors, ThrowOnError>;
+/**
+ * Edit a canvas
+ *
+ * Apply a graph diff to a canvas all at once: add nodes and edges, change inputs, disconnect edges, delete nodes. Every change lands or none does. Keep each edit to about 30 new nodes; build a bigger canvas one section per edit, so a mistake costs one small resend.
+ */
+declare const canvasEdit: <ThrowOnError extends boolean = false>(options: Options<CanvasEditData, ThrowOnError>) => RequestResult<CanvasEditResponses, CanvasEditErrors, ThrowOnError>;
+/**
+ * Arrange nodes on a canvas
+ *
+ * Lay out existing nodes with Fuser's layout instead of working out positions. Without layout it tidies them along their wiring, inputs to the left of what they feed; with layout it puts them in a row, column or grid in nodeIds order. Without an origin the block stays where the nodes are and slides clear of the nodes around it. Use it when the user asks to rearrange, line up or tidy nodes, or after resizing nodes that now overlap. It changes positions only.
+ */
+declare const canvasArrange: <ThrowOnError extends boolean = false>(options: Options<CanvasArrangeData, ThrowOnError>) => RequestResult<CanvasArrangeResponses, CanvasArrangeErrors, ThrowOnError>;
+/**
+ * Find node types
+ *
+ * Node types a canvas_edit diff may use, with what each is good at, its input ids and its output socket. Call it with no query first: it returns the recommended node for each common job. Search only when none of them fits.
+ */
+declare const catalogSearch: <ThrowOnError extends boolean = false>(options?: Options<CatalogSearchData, ThrowOnError>) => RequestResult<CatalogSearchResponses, CatalogSearchErrors, ThrowOnError>;
+/**
+ * Run a canvas
+ *
+ * Run the whole canvas or named nodes. Prices the run first and refuses it when it costs more than maxCredits; dryRun returns only the price. Starts a run once per idempotencyKey; check on it with run_get, not by calling run_start again.
+ */
+declare const runStart: <ThrowOnError extends boolean = false>(options: Options<RunStartData, ThrowOnError>) => RequestResult<RunStartResponses, RunStartErrors, ThrowOnError>;
+/**
+ * Check a run
+ *
+ * Status of a run you started, per node, with links to each node's results.
+ */
+declare const runGet: <ThrowOnError extends boolean = false>(options: Options<RunGetData, ThrowOnError>) => RequestResult<RunGetResponses, RunGetErrors, ThrowOnError>;
+/**
+ * Cancel a run
+ *
+ * Stop a run you started. Nodes already finished keep their results.
+ */
+declare const runCancel: <ThrowOnError extends boolean = false>(options: Options<RunCancelData, ThrowOnError>) => RequestResult<RunCancelResponses, RunCancelErrors, ThrowOnError>;
+/**
+ * Import an image or video
+ *
+ * Copy an image or video from a public URL into the canvas's assets and get a Fuser link for it. Use it before putting a web link on the canvas: it says straight away when the link can't be fetched, and the copy won't expire. For a file on the user's machine use upload_start.
+ */
+declare const mediaImport: <ThrowOnError extends boolean = false>(options: Options<MediaImportData, ThrowOnError>) => RequestResult<MediaImportResponses, MediaImportErrors, ThrowOnError>;
+/**
+ * Upload files
+ *
+ * Step 1 of putting files from the user's machine on a canvas, for agents that run commands on that machine (Claude Code, Codex, an IDE). List the files (up to 50): each comes back with a link to PUT it to, or done if Fuser already has it. Then call upload_finish with uploadId. In a chat app use upload_box instead; a cloud code sandbox can't reach these links.
+ */
+declare const uploadStart: <ThrowOnError extends boolean = false>(options: Options<UploadStartData, ThrowOnError>) => RequestResult<UploadStartResponses, UploadStartErrors, ThrowOnError>;
+/**
+ * Finish uploading files
+ *
+ * Step 2: returns a link for every file that arrived, to use as an ImageNode or VideoNode input, and says why for any that did not. For files the user is adding on the upload page, call it after they say they are done.
+ */
+declare const uploadFinish: <ThrowOnError extends boolean = false>(options: Options<UploadFinishData, ThrowOnError>) => RequestResult<UploadFinishResponses, UploadFinishErrors, ThrowOnError>;
+/**
+ * Look at media
+ *
+ * See Fuser images and 3D models as small previews, and the first frame of a video, with facts such as size, length and transparency. Look at results before describing or judging them.
+ */
+declare const mediaView: <ThrowOnError extends boolean = false>(options: Options<MediaViewData, ThrowOnError>) => RequestResult<MediaViewResponses, MediaViewErrors, ThrowOnError>;
+/**
+ * Find your media
+ *
+ * Search the images, videos, audio and 3D files you made or uploaded, by meaning ("the coral reef image", "a dog running on a beach") or by similarity to one you have. Without query or similarTo it lists the newest first. Look at matches with media_view.
+ */
+declare const mediaSearch: <ThrowOnError extends boolean = false>(options: Options<MediaSearchData, ThrowOnError>) => RequestResult<MediaSearchResponses, MediaSearchErrors, ThrowOnError>;
+/**
+ * Download media as a zip
+ *
+ * A link that downloads a canvas's results as one zip file, for when the user wants their files ('download everything', 'send me the images as a zip'). Give the user the link; it works for an hour. It changes nothing on the canvas.
+ */
+declare const mediaExport: <ThrowOnError extends boolean = false>(options: Options<MediaExportData, ThrowOnError>) => RequestResult<MediaExportResponses, MediaExportErrors, ThrowOnError>;
+/**
+ * Read your account
+ *
+ * Who you are, your personal credits and plan, and each workspace you belong to with your role, its plan, the team's credits and your monthly spend limit there. Runs on a workspace canvas spend that workspace's credits if you belong to it; runs on a personal canvas, or a workspace canvas shared with you from outside, spend yours.
+ */
+declare const accountGet: <ThrowOnError extends boolean = false>(options?: Options<AccountGetData, ThrowOnError>) => RequestResult<AccountGetResponses, AccountGetErrors, ThrowOnError>;
+/**
+ * Find a saved tool
+ *
+ * Search the canvas's tool library (tools you or your workspace built) and Fuser's featured tools by title and description. Place a match with tool_build toolId. Only worth it when a tool for the job likely exists; building a new one with tool_build prompt is fine too.
+ */
+declare const toolSearch: <ThrowOnError extends boolean = false>(options: Options<ToolSearchData, ThrowOnError>) => RequestResult<ToolSearchResponses, ToolSearchErrors, ThrowOnError>;
+/**
+ * Build a tool
+ *
+ * Turn a Tool node (type UtilityNode, added with canvas_edit) into a working tool: describe it in prompt and Fuser writes its code, or place a saved one with toolId. Tools do what generators can't: join, cut, trim or speed up videos, mix audio, crop, grid, filter, measure and convert between images, video, audio, 3D models, text and JSON (not PDF, ZIP or other files). Call it again with a prompt to change a built tool, or with neither to check on a build. Once built, wire its input sockets and set its controls with canvas_edit, then run it like any node; free tools cost nothing to run.
+ */
+declare const toolBuild: <ThrowOnError extends boolean = false>(options: Options<ToolBuildData, ThrowOnError>) => RequestResult<ToolBuildResponses, ToolBuildErrors, ThrowOnError>;
+//#endregion
+//#region src/pages.d.ts
+interface Page {
+  nextCursor: string | null;
+}
+/**
+ * A paged list: await it for the first page, or `for await` it for every
+ * item on every page.
+ */
+export declare class PagePromise<P extends Page, I> implements PromiseLike<P>, AsyncIterable<I> {
+  #private;
+  constructor(load: (cursor?: string) => Promise<P>, items: (page: P) => readonly I[]);
+  then<A = P, B = never>(onfulfilled?: ((value: P) => A | PromiseLike<A>) | null, onrejected?: ((reason: unknown) => B | PromiseLike<B>) | null): Promise<A | B>;
+  pages(): AsyncGenerator<P>;
+  [Symbol.asyncIterator](): AsyncGenerator<I>;
+  /** Every item on every page. */
+  all(): Promise<I[]>;
+}
+//#endregion
+//#region src/fuser.d.ts
+type Sdk = typeof sdk_gen_d_exports;
+/** A generated operation, e.g. `canvasEdit`. */
+type OperationKey = keyof Sdk;
+type Snake<S extends string> = S extends `${infer Head}${infer Rest}` ? `${Head extends Lowercase<Head> ? Head : `_${Lowercase<Head>}`}${Snake<Rest>}` : S;
+/** An MCP tool and REST path name, e.g. `canvas_edit`. */
+type ToolName = Snake<OperationKey>;
+type KeyOf<N extends ToolName> = { [K in OperationKey]: Snake<K> extends N ? K : never; }[OperationKey];
+type OptionsOf<K extends OperationKey> = NonNullable<Parameters<Sdk[K]>[0]>;
+type Field<K extends OperationKey, F extends 'body' | 'query'> = OptionsOf<K> extends { [P in F]?: infer V; } ? NonNullable<V> : never;
+type InOf<K extends OperationKey> = [Field<K, 'body'>] extends [never] ? 'query' : 'body';
+type ArgsOf<K extends OperationKey> = [Field<K, InOf<K>>] extends [never] ? void : Field<K, InOf<K>>;
+type ResultOf<K extends OperationKey> = Extract<Awaited<ReturnType<Sdk[K]>>, {
+  error: undefined;
+}>['data'];
+/** Exactly the arguments an agent passes to the MCP tool. */
+type ToolArgs<N extends ToolName> = ArgsOf<KeyOf<N>>;
+/** Exactly the JSON the MCP tool returns. */
+type ToolResult<N extends ToolName> = ResultOf<KeyOf<N>>;
+type Resource = ToolName extends (infer N) ? N extends `${infer R}_${string}` ? R : never : never;
+/**
+ * One namespace per resource and one method per tool: `canvas_list` is
+ * `fuser.canvas.list()`. A new or renamed tool fails the build until the
+ * class covers it.
+ */
+type Surface = { [R in Resource]: { [N in ToolName as N extends `${R}_${infer M}` ? M : never]: (args: ToolArgs<N>, options?: RequestOptions) => PromiseLike<ToolResult<N>>; }; };
+interface RequestOptions {
+  signal?: AbortSignal;
+  /** Per attempt, on top of any `waitSeconds`. */
+  timeoutMs?: number;
+  maxRetries?: number;
+  headers?: Record<string, string>;
+}
+interface WaitOptions {
+  /** Give up after this long. Defaults to 30 minutes for runs, 10 for builds. */
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+interface FuserOptions {
+  /** Defaults to the `FUSER_API_KEY` environment variable. */
+  apiKey?: string;
+  /** Defaults to `https://api.fuser.studio`. */
+  baseUrl?: string;
+  fetch?: typeof fetch;
+  /** Per attempt. Defaults to 60 seconds. */
+  timeoutMs?: number;
+  /** Defaults to 2. */
+  maxRetries?: number;
+  beforeSend?: (request: Request) => Request | void | Promise<Request | void>;
+  afterSend?: (response: Response, request: Request) => void | Promise<void>;
+  /** An API key acts as you; only set this if the page is yours alone. */
+  dangerouslyAllowBrowser?: boolean;
+}
+type RunStartResult = ToolResult<'run_start'>;
+type RunSummary = ToolResult<'run_get'>;
+type ToolBuildResult = ToolResult<'tool_build'>;
+declare abstract class StartedCall<T> implements PromiseLike<T> {
+  protected readonly started: Promise<T>;
+  constructor(started: Promise<T>);
+  then<A = T, B = never>(onfulfilled?: ((value: T) => A | PromiseLike<A>) | null, onrejected?: ((reason: unknown) => B | PromiseLike<B>) | null): Promise<A | B>;
+}
+/** `run.start()`: await for the start result, or `.wait()` for the finished run. */
+export declare class RunCall extends StartedCall<RunStartResult> {
+  #private;
+  constructor(started: Promise<RunStartResult>, wait: (runId: string, options?: WaitOptions) => Promise<RunSummary>);
+  /** The run once it stops running. Throws if it was refused or only priced. */
+  wait(options?: WaitOptions): Promise<RunSummary>;
+}
+/** `tool.build()`: await for its state now, or `.wait()` until it's built. */
+export declare class ToolBuildCall extends StartedCall<ToolBuildResult> {
+  #private;
+  constructor(started: Promise<ToolBuildResult>, check: (signal?: AbortSignal) => Promise<ToolBuildResult>);
+  /** The tool once its build stops; check `status` for built or failed. */
+  wait(options?: WaitOptions): Promise<ToolBuildResult>;
+}
+interface UploadInput {
+  fileName: string;
+  data: Blob | ArrayBuffer | Uint8Array;
+  /** Required unless `data` is a Blob with a type. */
+  contentType?: string;
+}
+/**
+ * The Fuser API. Each tool is a method named after it: `canvas_edit` is
+ * `fuser.canvas.edit()`, with the same arguments and result as the MCP tool.
+ */
+export declare class Fuser implements Surface {
+  #private;
+  readonly client: Client;
+  readonly account: {
+    get: (_args?: void | undefined, options?: RequestOptions) => Promise<{
+      name: string | null;
+      email: string;
+      personalCredits: number;
+      personalPlan: {
+        name: string;
+        trial: boolean;
+        canvases: {
+          used: number | null;
+          limit: number | null;
+        };
+        nodesPerCanvas: number | null;
+        runAll: boolean;
+        buildTools: boolean;
+        searchByMeaning: boolean;
+        managesPlan: boolean;
+        plansUrl: string;
+      };
+      workspaces: Array<{
+        workspaceId: string;
+        name: string;
+        role: "owner" | "admin" | "member";
+        credits: number;
+        canSpend: boolean;
+        monthlySpendLimit: {
+          limit: number;
+          remaining: number;
+        } | null;
+        plan: {
+          name: string;
+          trial: boolean;
+          canvases: {
+            used: number | null;
+            limit: number | null;
+          };
+          nodesPerCanvas: number | null;
+          runAll: boolean;
+          buildTools: boolean;
+          searchByMeaning: boolean;
+          managesPlan: boolean;
+          plansUrl: string;
+        };
+      }>;
+    }>;
+  };
+  readonly canvas: {
+    /** Await for a page, or `for await` for every canvas. */
+    list: (args?: ToolArgs<"canvas_list">, options?: RequestOptions) => PagePromise<{
+      canvases: Array<{
+        canvasId: string;
+        title: string;
+        workspaceId: string | null;
+        updatedAt: string | null;
+        url: string;
+      }>;
+      nextCursor: string | null;
+    } & {
+      nextCursor: string | null;
+    }, {
+      canvasId: string;
+      title: string;
+      workspaceId: string | null;
+      updatedAt: string | null;
+      url: string;
+    }>;
+    /** Await for a page, or `for await` for every node. */
+    get: (args: ToolArgs<"canvas_get">, options?: RequestOptions) => PagePromise<{
+      canvasId: string;
+      title: string;
+      url: string;
+      revision: number;
+      summary: {
+        nodeCount: number;
+        edgeCount: number;
+        nodesByType: {
+          [key: string]: number;
+        };
+        bounds: {
+          x: number;
+          y: number;
+          width: number;
+          height: number;
+        } | null;
+      };
+      nodes: Array<{
+        id: string;
+        type?: string;
+        label?: string;
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        group?: string;
+        in: Array<string>;
+        out: Array<string>;
+        values?: {
+          [key: string]: string;
+        };
+        results?: Array<string>;
+      }>;
+      edges: Array<{
+        from: string;
+        to: string;
+      }>;
+      nextCursor: string | null;
+    } & {
+      nextCursor: string | null;
+    }, {
+      id: string;
+      type?: string;
+      label?: string;
+      x?: number;
+      y?: number;
+      width?: number;
+      height?: number;
+      group?: string;
+      in: Array<string>;
+      out: Array<string>;
+      values?: {
+        [key: string]: string;
+      };
+      results?: Array<string>;
+    }>;
+    /** `idempotencyKey` defaults to a new one per call. */
+    edit: (args: Omit<ToolArgs<"canvas_edit">, "idempotencyKey"> & {
+      idempotencyKey?: string;
+    }, options?: RequestOptions) => Promise<{
+      canvasId: string;
+      url: string;
+      revision: number;
+      createdNodeIds: {
+        [key: string]: string;
+      };
+      warnings: Array<string>;
+      overlaps: Array<{
+        nodeId: string;
+        overlapsWith: string;
+      }>;
+      replayed: boolean;
+    }>;
+    arrange: (args: ToolArgs<"canvas_arrange">, options?: RequestOptions) => Promise<{
+      canvasId: string;
+      url: string;
+      revision: number;
+      arranged: number;
+      moved: number;
+      bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+      };
+      overlaps: Array<{
+        nodeId: string;
+        overlapsWith: string;
+      }>;
+    }>;
+  };
+  readonly catalog: {
+    search: (args?: ToolArgs<"catalog_search">, options?: RequestOptions) => Promise<{
+      matched: boolean;
+      note?: string;
+      recommended: Array<{
+        job: string;
+        type: string;
+        inputs?: {
+          [key: string]: string;
+        };
+        credits?: number;
+      }>;
+      nodeTypes: Array<{
+        type: string;
+        category: "image" | "video" | "text" | "mesh" | "primitive";
+        purpose: string;
+        inputs: Array<{
+          id: string;
+          kind: "text" | "number" | "boolean" | "enum" | "image" | "video" | "media";
+          description: string;
+          required?: boolean;
+          multiple?: boolean;
+          values?: Array<string>;
+          min?: number;
+          max?: number;
+          defaultValue?: string | number | boolean;
+        }>;
+        output: string;
+        notes?: Array<string>;
+        prices?: Array<{
+          variant: string;
+          credits: number;
+          settings: string;
+        }>;
+      }>;
+    }>;
+  };
+  readonly run: {
+    /** `idempotencyKey` defaults to a new one per call. Add `.wait()` to wait. */
+    start: (args: ToolArgs<"run_start">, options?: RequestOptions) => RunCall;
+    get: (args: ToolArgs<"run_get">, options?: RequestOptions) => Promise<{
+      runId: string;
+      status: "running" | "completed" | "failed" | "cancelled";
+      quotedCredits: number;
+      startedAt: string;
+      completedAt?: string;
+      nodes: Array<{
+        nodeId: string;
+        type: string | null;
+        status: "pending" | "running" | "succeeded" | "failed" | "skipped" | "cancelled" | "unknown";
+        error?: string;
+        outputs: Array<string>;
+        text?: string;
+      }>;
+      plansUrl?: string;
+    }>;
+    cancel: (args: ToolArgs<"run_cancel">, options?: RequestOptions) => Promise<{
+      cancelled: boolean;
+    }>;
+    /** Checks a run until it stops running. */
+    wait: (args: {
+      canvasId: string;
+      runId: string;
+    }, options?: WaitOptions) => Promise<{
+      runId: string;
+      status: "running" | "completed" | "failed" | "cancelled";
+      quotedCredits: number;
+      startedAt: string;
+      completedAt?: string;
+      nodes: Array<{
+        nodeId: string;
+        type: string | null;
+        status: "pending" | "running" | "succeeded" | "failed" | "skipped" | "cancelled" | "unknown";
+        error?: string;
+        outputs: Array<string>;
+        text?: string;
+      }>;
+      plansUrl?: string;
+    }>;
+  };
+  readonly media: {
+    export: (args: ToolArgs<"media_export">, options?: RequestOptions) => Promise<{
+      url: string;
+      expiresAt: string;
+      fileCount: number;
+      files: Array<{
+        name: string;
+        nodeId: string;
+        url: string;
+      }>;
+    }>;
+    import: (args: ToolArgs<"media_import">, options?: RequestOptions) => Promise<{
+      url: string;
+      mimeType: string;
+    }>;
+    /** Await for a page, or `for await` for every match. */
+    search: (args: ToolArgs<"media_search">, options?: RequestOptions) => PagePromise<{
+      assets: Array<{
+        mediaId: string;
+        url: string;
+        type: string | null;
+        title: string | null;
+        description: string | null;
+        createdAt: string | null;
+        canvases: Array<{
+          canvasId: string;
+          title: string;
+        }>;
+      }>;
+      nextCursor: string | null;
+    } & {
+      nextCursor: string | null;
+    }, {
+      mediaId: string;
+      url: string;
+      type: string | null;
+      title: string | null;
+      description: string | null;
+      createdAt: string | null;
+      canvases: Array<{
+        canvasId: string;
+        title: string;
+      }>;
+    }>;
+    view: (args: ToolArgs<"media_view">, options?: RequestOptions) => Promise<{
+      items: Array<{
+        url: string;
+        kind: "image" | "video" | "audio" | "mesh" | "unknown";
+        facts?: {
+          [key: string]: string | number | boolean;
+        };
+        previews: Array<{
+          mimeType: string;
+          data: string;
+          atSeconds?: number;
+        }>;
+        note?: string;
+      }>;
+    }>;
+  };
+  readonly upload: {
+    start: (args: ToolArgs<"upload_start">, options?: RequestOptions) => Promise<{
+      uploadId: string;
+      uploadPage: string;
+      expiresAt: string;
+      files: Array<{
+        fileName: string;
+        status: "upload";
+        method: "PUT";
+        url: string;
+        headers: {
+          [key: string]: string;
+        };
+      } | {
+        fileName: string;
+        status: "done";
+        asset: {
+          url: string;
+          mimeType: string;
+        };
+      }>;
+    }>;
+    finish: (args: ToolArgs<"upload_finish">, options?: RequestOptions) => Promise<{
+      files: Array<{
+        url: string;
+        mimeType: string;
+        status: "done";
+        fileName: string;
+      } | {
+        status: "failed";
+        fileName: string;
+        error: string;
+      }>;
+    }>;
+    /** Hashes, starts, sends and finishes in one call. */
+    files: (canvasId: string, files: UploadInput[], options?: RequestOptions) => Promise<({
+      url: string;
+      mimeType: string;
+      status: "done";
+      fileName: string;
+    } | {
+      status: "failed";
+      fileName: string;
+      error: string;
+    })[]>;
+  };
+  readonly tool: {
+    search: (args: ToolArgs<"tool_search">, options?: RequestOptions) => Promise<{
+      tools: Array<{
+        toolId: string;
+        description: string | null;
+        featured: boolean;
+        tool: {
+          title: string;
+          mode: "free" | "paid";
+          inputs: Array<{
+            socket: string;
+            kind: "image" | "video" | "audio" | "mesh" | "text";
+            many: boolean;
+            required: boolean;
+          }>;
+          controls: Array<{
+            socket: string;
+            label: string;
+            kind: "slider";
+            default: number;
+            min: number;
+            max: number;
+          } | {
+            socket: string;
+            label: string;
+            kind: "dropdown";
+            default: string;
+            options: Array<string>;
+          } | {
+            socket: string;
+            label: string;
+            kind: "switch";
+            default: boolean;
+          }>;
+          outputs: Array<{
+            socket: string;
+            kind: "image" | "video" | "audio" | "text" | "json";
+          }>;
+        };
+      }>;
+    }>;
+    /** Add `.wait()` to wait until it's built. */
+    build: (args: ToolArgs<"tool_build">, options?: RequestOptions) => ToolBuildCall;
+  };
+  constructor(options?: FuserOptions);
+  /** Calls a tool by its MCP name, with the exact arguments an agent sent. */
+  call<N extends ToolName>(name: N, args: ToolArgs<N>, options?: RequestOptions): Promise<ToolResult<N>>;
+}
+//#endregion
+export type { FuserErrorDetails, FuserOptions, RequestOptions, ToolArgs, ToolName, ToolResult, UploadInput, WaitOptions };