@nodaro/sdk 2.2.0 → 2.5.0

package/dist/index.cjs

@@ -2138,6 +2138,22 @@ var MediaResource = class {
   imageCollage(input) {
     return this.client.request("POST", "/v1/image-collage", { body: input });
   }
+  /**
+   * Place 1–12 layers — pictures, real text, QR codes, shapes — on a base image,
+   * pixel-exactly (`POST /v1/image-overlay`) — local, deterministic, no AI.
+   * Every layer position/size is a PERCENT of the base image: `anchor` (nine
+   * positions, default `"center"`), `x`/`y` (offset from the anchor in % of
+   * the base width/height; negative on a right/bottom anchor moves inward),
+   * `width` (% of the base width, default 25 — height follows the layer's
+   * aspect unless `height` is set). Plus `opacity` (0..1), `rotation`
+   * (degrees), `blend` (`"over"` | `"multiply"` | `"screen"`), `fit`,
+   * `shadow` and `roundedCorners`. The output keeps the base's pixel size
+   * unless `canvas` is set. Flat credit cost. Poll `jobs.get(jobId)` for the
+   * finished image.
+   */
+  imageOverlay(input) {
+    return this.client.request("POST", "/v1/image-overlay", { body: input });
+  }
   /**
    * Trim a video to a range (`POST /v1/trim-video`). Give the range in whichever
    * unit fits: `startTime`/`endTime` seconds, `trim*Frames`, `trim*Seconds`, or
@@ -2543,7 +2559,7 @@ var RecastResource = class {
   }
 };
 
-// src/resources/studio.ts
+// src/resources/studio-productions.ts
 function isStudioGenerateEstimate(result) {
   return result.dryRun === true;
 }
@@ -2775,11 +2791,80 @@ var StudioProductionsResource = class {
     return res.data.production;
   }
 };
+
+// src/resources/studio.ts
+var root = "/v1/studio/productions";
+var path = (id) => `${root}/${encodeURIComponent(id)}`;
 var StudioResource = class {
-  productions;
   constructor(client) {
+    this.client = client;
     this.productions = new StudioProductionsResource(client);
   }
+  client;
+  productions;
+  capabilities() {
+    return this.client.request("GET", `${root}/capabilities`);
+  }
+  skill() {
+    return this.client.request("GET", `${root}/skill`);
+  }
+  list(options = {}) {
+    return this.client.request("GET", root, { query: options });
+  }
+  get(id, options = {}) {
+    return this.client.request("GET", path(id), { query: { detail: options.detail, shot_id: options.shotId } });
+  }
+  validatePlan(plan) {
+    return this.client.request("POST", `${root}/validate`, { body: { plan } });
+  }
+  create(input) {
+    return this.client.request("POST", root, { body: input });
+  }
+  /** Import a portable document through the compatible server writer.
+   * Retained frame media requires an authorized source; acceptance never transfers. */
+  importBundle(input) {
+    return this.client.request("POST", `${root}/import-bundle`, { body: input });
+  }
+  /** Append a bundle's scenes and frame closure under an exact destination revision. */
+  appendBundle(id, input) {
+    return this.client.request("POST", `${path(id)}/import-bundle`, { body: input });
+  }
+  /** Copy a saved production. Linked copies retain verified inputs, remap
+   * dependencies and require fresh frame acceptance; they start no media jobs. */
+  clone(id, input = {}) {
+    return this.client.request("POST", `${path(id)}/clone`, { body: input });
+  }
+  edit(id, input) {
+    return this.client.request("POST", `${path(id)}/ops`, { body: input });
+  }
+  /** Audience-authorized sharing; an expected revision prevents publication
+   * of concurrent edits the caller has not reviewed. */
+  setShared(id, input) {
+    return this.client.request("POST", `${path(id)}/share`, { body: input });
+  }
+  /** Save ordinary editor fields against the loaded revision. Protected frame
+   * and job state can only change through their dedicated semantic actions. */
+  saveEditorState(id, input) {
+    return this.edit(id, {
+      baseVersion: input.expectedVersion,
+      strict: true,
+      ...input.clientRequestId ? { clientRequestId: input.clientRequestId } : {},
+      ops: [{ op: "save_editor_state", expectedVersion: input.expectedVersion, graph: input.graph }]
+    });
+  }
+  generateKeyframe(id, input) {
+    return this.client.request("POST", `${path(id)}/generate`, { body: { ...input, kind: "keyframe" } });
+  }
+  generateShot(id, input) {
+    return this.client.request("POST", `${path(id)}/generate`, { body: input });
+  }
+  /** A separate explicit review action; generation never calls this method. */
+  acceptKeyframe(id, input, concurrency = {}) {
+    return this.edit(id, { ...concurrency, ops: [{ ...input, op: "accept_keyframe_result" }] });
+  }
+  reconcile(id) {
+    return this.client.request("POST", `${path(id)}/reconcile`, { body: {} });
+  }
 };
 
 // src/resources/community.ts
@@ -3163,7 +3248,7 @@ var WorkspacesResource = class {
     return this.client.requestText("GET", `/v1/workspaces/${encodeURIComponent(id)}/usage`, { query: { ...opts, format: "csv" } });
   }
 };
-var SDK_VERSION = "2.2.0" ;
+var SDK_VERSION = "2.5.0" ;
 var CLIENT_HEADER = "X-Nodaro-Client";
 var isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
 var NodaroClient = class _NodaroClient {
@@ -3295,8 +3380,8 @@ var NodaroClient = class _NodaroClient {
    * stalled CSV stream aborts, it does not hang forever). Both the JSON path
    * ({@link request}) and the text path ({@link requestText}) go through here.
    */
-  async send(method, path, options, read) {
-    const url = this.buildUrl(path, options.query);
+  async send(method, path2, options, read) {
+    const url = this.buildUrl(path2, options.query);
     const token = await this.auth.getToken();
     const isFormData = typeof FormData !== "undefined" && options.body instanceof FormData;
     const headers = {
@@ -3336,14 +3421,14 @@ var NodaroClient = class _NodaroClient {
     }
   }
   /** Authenticated, bounded binary reads through the normal timeout/error transport. */
-  async requestBytes(method, path, options) {
+  async requestBytes(method, path2, options) {
     if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1) throw new Error("maxBytes must be a positive integer");
-    return this.send(method, path, options, (response) => readBinaryResponse(response, options.maxBytes));
+    return this.send(method, path2, options, (response) => readBinaryResponse(response, options.maxBytes));
   }
-  async request(method, path, options = {}) {
+  async request(method, path2, options = {}) {
     return this.send(
       method,
-      path,
+      path2,
       options,
       async (res) => (
         // 204 No Content
@@ -3356,8 +3441,8 @@ var NodaroClient = class _NodaroClient {
    * are still the JSON envelope and throw the same typed errors, and the read is
    * bounded by the same timeout as the request.
    */
-  async requestText(method, path, options = {}) {
-    return this.send(method, path, options, (res) => res.text());
+  async requestText(method, path2, options = {}) {
+    return this.send(method, path2, options, (res) => res.text());
   }
   /**
    * `GET /v1/me` → the authenticated user's identity (see {@link UserIdentity}).
@@ -3376,9 +3461,9 @@ var NodaroClient = class _NodaroClient {
     const res = await this.request("GET", "/v1/me");
     return res.data;
   }
-  buildUrl(path, query) {
+  buildUrl(path2, query) {
     const base = this.baseUrl || (typeof window !== "undefined" ? window.location.origin : "http://placeholder");
-    const url = new URL(path, base);
+    const url = new URL(path2, base);
     const fullUrl = this.baseUrl ? url.toString() : url.pathname + url.search;
     if (query) {
       const u = new URL(this.baseUrl ? fullUrl : fullUrl, base);