@remotion-studio/sdk 0.1.0

package/dist/sdk/client.js

@@ -0,0 +1,413 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMotionGraphicsArtifact = exports.createRemotionStudioClient = exports.RemotionStudioError = void 0;
+const artifact_1 = require("../shared/artifact");
+Object.defineProperty(exports, "createMotionGraphicsArtifact", { enumerable: true, get: function () { return artifact_1.createMotionGraphicsArtifact; } });
+const sanitize_1 = require("../shared/sanitize");
+const sleep = async (ms, signal) => new Promise((resolve, reject) => {
+    const abortReason = signal?.reason ?? new DOMException("Aborted", "AbortError");
+    if (signal?.aborted) {
+        reject(abortReason);
+        return;
+    }
+    const timeoutId = setTimeout(() => {
+        cleanup();
+        resolve();
+    }, ms);
+    const onAbort = () => {
+        clearTimeout(timeoutId);
+        cleanup();
+        reject(abortReason);
+    };
+    const cleanup = () => {
+        if (signal) {
+            signal.removeEventListener("abort", onAbort);
+        }
+    };
+    if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+    }
+});
+class RemotionStudioError extends Error {
+    constructor(data) {
+        super(data.message);
+        this.name = "RemotionStudioError";
+        this.type = data.type;
+        this.status = data.status;
+        this.failedEdit = data.failedEdit;
+        this.availableCredits = data.availableCredits;
+        this.requiredCredits = data.requiredCredits;
+    }
+}
+exports.RemotionStudioError = RemotionStudioError;
+const mergeHeaders = (defaultHeaders, requestHeaders) => {
+    const headers = new Headers(defaultHeaders ?? {});
+    if (requestHeaders) {
+        const extraHeaders = new Headers(requestHeaders);
+        extraHeaders.forEach((value, key) => {
+            headers.set(key, value);
+        });
+    }
+    return headers;
+};
+const resolveUrl = (baseUrl, path) => {
+    if (!baseUrl) {
+        return path;
+    }
+    return new URL(path, baseUrl).toString();
+};
+const normalizeErrorType = (value) => {
+    if (value === "validation" ||
+        value === "edit_failed" ||
+        value === "authentication" ||
+        value === "authorization" ||
+        value === "insufficient_credits" ||
+        value === "billing_unavailable" ||
+        value === "not_found") {
+        return value;
+    }
+    return "api";
+};
+const parseErrorResponse = async (response) => {
+    const data = await response.json().catch(() => ({}));
+    const message = typeof data.error === "string"
+        ? data.error
+        : typeof data.message === "string"
+            ? data.message
+            : `API error: ${response.status}`;
+    throw new RemotionStudioError({
+        message,
+        type: normalizeErrorType(data.type === "error" && typeof data.errorType === "string"
+            ? data.errorType
+            : data.type),
+        status: response.status,
+        failedEdit: data.failedEdit,
+        availableCredits: typeof data.availableCredits === "number"
+            ? data.availableCredits
+            : undefined,
+        requiredCredits: typeof data.requiredCredits === "number"
+            ? data.requiredCredits
+            : undefined,
+    });
+};
+const assertJsonResponse = async (response) => {
+    if (!response.ok) {
+        await parseErrorResponse(response);
+    }
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.includes("application/json")) {
+        throw new RemotionStudioError({
+            message: "Expected a JSON response from the API.",
+            type: "api",
+            status: response.status,
+        });
+    }
+    return (await response.json());
+};
+const createPostRequest = async (fetchImpl, url, body, headers, signal) => {
+    const response = await fetchImpl(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal,
+    });
+    return assertJsonResponse(response);
+};
+const createGetRequest = async (fetchImpl, url, headers, signal) => {
+    const response = await fetchImpl(url, {
+        method: "GET",
+        headers,
+        signal,
+    });
+    return assertJsonResponse(response);
+};
+const createRemotionStudioClient = ({ baseUrl, fetch: providedFetch, headers: defaultHeaders, } = {}) => {
+    const fetchImpl = providedFetch ?? fetch;
+    const postJson = (path, body, options) => {
+        const headers = mergeHeaders(defaultHeaders, options?.headers);
+        if (!headers.has("Content-Type")) {
+            headers.set("Content-Type", "application/json");
+        }
+        return createPostRequest(fetchImpl, resolveUrl(baseUrl, path), body, headers, options?.signal);
+    };
+    const getJson = (path, options) => {
+        const headers = mergeHeaders(defaultHeaders, options?.headers);
+        return createGetRequest(fetchImpl, resolveUrl(baseUrl, path), headers, options?.signal);
+    };
+    const pollJob = async (path, jobLabel, options = {}) => {
+        const { headers, intervalMs = 2000, timeoutMs, signal, onUpdate, } = options;
+        const startedAt = Date.now();
+        while (true) {
+            if (timeoutMs != null && Date.now() - startedAt > timeoutMs) {
+                throw new RemotionStudioError({
+                    message: `${jobLabel} did not complete within ${timeoutMs}ms.`,
+                    type: "api",
+                });
+            }
+            const job = await getJson(path, { headers, signal });
+            onUpdate?.(job);
+            if (job.status === "completed" && job.result) {
+                return job.result;
+            }
+            if (job.status === "failed") {
+                throw new RemotionStudioError({
+                    message: job.error?.message ??
+                        `${jobLabel} failed without an error message.`,
+                    type: job.error?.type ?? "api",
+                    status: job.error?.status,
+                    availableCredits: job.error?.availableCredits,
+                    requiredCredits: job.error?.requiredCredits,
+                });
+            }
+            await sleep(intervalMs, signal);
+        }
+    };
+    const unwrapRenderEnvelope = async (response) => {
+        if (!response.ok) {
+            await parseErrorResponse(response);
+        }
+        const payload = await assertJsonResponse(response);
+        if (payload.type !== "success" || typeof payload.data === "undefined") {
+            throw new RemotionStudioError({
+                message: "Expected a successful render response from the API.",
+                type: "api",
+                status: response.status,
+            });
+        }
+        return payload.data;
+    };
+    const postRenderJson = async (path, body, options) => {
+        const headers = mergeHeaders(defaultHeaders, options?.headers);
+        if (!headers.has("Content-Type")) {
+            headers.set("Content-Type", "application/json");
+        }
+        const response = await fetchImpl(resolveUrl(baseUrl, path), {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: options?.signal,
+        });
+        return unwrapRenderEnvelope(response);
+    };
+    return {
+        async generate(request, options) {
+            return postJson("/api/generate", {
+                ...request,
+                streaming: false,
+            }, options);
+        },
+        async edit(request, options) {
+            return postJson("/api/edit", request, options);
+        },
+        async generateAsync(request, options) {
+            return postJson("/api/generate/async", request, options);
+        },
+        async editAsync(request, options) {
+            return postJson("/api/edit/async", request, options);
+        },
+        async getGenerationJob(jobId, options) {
+            return getJson(`/api/generate/async/${jobId}`, options);
+        },
+        async getEditJob(jobId, options) {
+            return getJson(`/api/edit/async/${jobId}`, options);
+        },
+        async pollGenerationJob(jobId, options = {}) {
+            return pollJob(`/api/generate/async/${jobId}`, `Generation job ${jobId}`, options);
+        },
+        async pollEditJob(jobId, options = {}) {
+            return pollJob(`/api/edit/async/${jobId}`, `Edit job ${jobId}`, options);
+        },
+        async render(request, options) {
+            return postRenderJson("/api/render/render", request, options);
+        },
+        async getRenderProgress(request, options) {
+            return postRenderJson("/api/render/progress", request, options);
+        },
+        async pollRenderProgress(request, options = {}) {
+            const { headers, intervalMs = 2000, timeoutMs, signal, onUpdate, } = options;
+            const startedAt = Date.now();
+            while (true) {
+                if (timeoutMs != null && Date.now() - startedAt > timeoutMs) {
+                    throw new RemotionStudioError({
+                        message: `Render ${request.id} did not complete within ${timeoutMs}ms.`,
+                        type: "api",
+                    });
+                }
+                const progress = await postRenderJson("/api/render/progress", request, { headers, signal });
+                onUpdate?.(progress);
+                if (progress.type === "done") {
+                    return progress;
+                }
+                if (progress.type === "error") {
+                    throw new RemotionStudioError({
+                        message: progress.message,
+                        type: "api",
+                    });
+                }
+                await sleep(intervalMs, signal);
+            }
+        },
+        async generateStream(request, callbacks = {}, options) {
+            const headers = mergeHeaders(defaultHeaders, options?.headers);
+            if (!headers.has("Content-Type")) {
+                headers.set("Content-Type", "application/json");
+            }
+            const response = await fetchImpl(resolveUrl(baseUrl, "/api/generate"), {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    ...request,
+                    streaming: true,
+                }),
+            });
+            if (!response.ok) {
+                await parseErrorResponse(response);
+            }
+            const contentType = response.headers.get("content-type") || "";
+            if (contentType.includes("application/json")) {
+                const data = await assertJsonResponse(response);
+                callbacks.onMetadata?.({
+                    skills: data.metadata.skills,
+                    model: data.metadata.model,
+                    preset: data.metadata.preset,
+                });
+                callbacks.onCode?.(data.code);
+                return {
+                    code: data.code,
+                    reasoning: "",
+                    metadata: {
+                        skills: data.metadata.skills,
+                        model: data.metadata.model,
+                        preset: data.metadata.preset,
+                    },
+                    summary: data.summary,
+                    artifact: data.artifact,
+                    thread: data.thread,
+                };
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new RemotionStudioError({
+                    message: "No response body",
+                    type: "api",
+                    status: response.status,
+                });
+            }
+            const decoder = new TextDecoder();
+            let accumulatedText = "";
+            let reasoningText = "";
+            let buffer = "";
+            let streamMetadata = {};
+            let finalSummary;
+            let finalArtifact;
+            let finalThread;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (!line.startsWith("data:")) {
+                        continue;
+                    }
+                    const data = line.slice(5).trimStart();
+                    if (data === "[DONE]") {
+                        continue;
+                    }
+                    try {
+                        const event = JSON.parse(data);
+                        if (event.type === "metadata") {
+                            streamMetadata = {
+                                skills: event.skills,
+                                model: event.model,
+                                preset: event.preset,
+                            };
+                            callbacks.onMetadata?.(streamMetadata);
+                        }
+                        else if (event.type === "reasoning-start") {
+                            callbacks.onReasoningStart?.();
+                        }
+                        else if (event.type === "reasoning-delta" ||
+                            event.type === "reasoning") {
+                            const delta = String(event.delta ?? event.text ?? "");
+                            if (!delta) {
+                                continue;
+                            }
+                            reasoningText += delta;
+                            callbacks.onReasoning?.(reasoningText);
+                        }
+                        else if (event.type === "text-start") {
+                            callbacks.onTextStart?.();
+                        }
+                        else if (event.type === "text-delta" ||
+                            event.type === "text" ||
+                            event.type === "response.output_text.delta" ||
+                            event.type === "output_text.delta") {
+                            const delta = String(event.delta ?? event.text ?? "");
+                            if (!delta) {
+                                continue;
+                            }
+                            accumulatedText += delta;
+                            callbacks.onCode?.((0, sanitize_1.stripMarkdownFences)(accumulatedText));
+                        }
+                        else if (event.type === "complete") {
+                            if (typeof event.code === "string") {
+                                accumulatedText = event.code;
+                            }
+                            finalSummary =
+                                typeof event.summary === "string" ? event.summary : undefined;
+                            finalArtifact = event.artifact;
+                            finalThread = event.thread;
+                        }
+                        else if (event.type === "error") {
+                            const streamError = typeof event.error === "string"
+                                ? event.error
+                                : typeof event.error?.message === "string"
+                                    ? event.error.message
+                                    : typeof event.message === "string"
+                                        ? event.message
+                                        : typeof event.errorText === "string"
+                                            ? event.errorText
+                                            : "Model stream returned an unknown error.";
+                            throw new RemotionStudioError({
+                                message: streamError,
+                                type: normalizeErrorType(event.errorType ?? event.type),
+                                availableCredits: typeof event.availableCredits === "number"
+                                    ? event.availableCredits
+                                    : undefined,
+                                requiredCredits: typeof event.requiredCredits === "number"
+                                    ? event.requiredCredits
+                                    : undefined,
+                            });
+                        }
+                    }
+                    catch (error) {
+                        if (error instanceof SyntaxError) {
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            const finalCode = (0, sanitize_1.extractComponentCode)((0, sanitize_1.stripMarkdownFences)(accumulatedText));
+            if (!finalCode.trim()) {
+                throw new RemotionStudioError({
+                    message: "No code was returned by the model stream. Try a different model or prompt.",
+                    type: "api",
+                });
+            }
+            return {
+                code: (0, sanitize_1.sanitizeGeneratedCode)(finalCode),
+                reasoning: reasoningText,
+                metadata: streamMetadata,
+                summary: finalSummary,
+                artifact: finalArtifact,
+                thread: finalThread,
+            };
+        },
+    };
+};
+exports.createRemotionStudioClient = createRemotionStudioClient;

package/dist/sdk/index.d.ts

@@ -0,0 +1,4 @@
+export { DEFAULT_MOTION_GRAPHICS_DURATION_IN_FRAMES, DEFAULT_MOTION_GRAPHICS_FPS, DEFAULT_MOTION_GRAPHICS_HEIGHT, DEFAULT_MOTION_GRAPHICS_WIDTH, MOTION_GRAPHICS_ARTIFACT_VERSION, MOTION_GRAPHICS_RUNTIME, createMotionGraphicsArtifact, type MotionGraphicsArtifact, type MotionGraphicsArtifactV1, type MotionGraphicsCompositionProps, type MotionGraphicsEditType, type MotionGraphicsPresetReference, } from "../shared/artifact";
+export { extractComponentCode, sanitizeGeneratedCode, stripMarkdownFences, } from "../shared/sanitize";
+export { RemotionStudioError, createRemotionStudioClient, } from "./client";
+export type { AsyncWebhookCallback, ConversationContextMessage, EditAsyncRequest, EditJobAcceptedResponse, EditJobResponse, EditOperation, EditRequest, EditResponse, ErrorCorrectionContext, FailedEditInfo, GenerateAsyncRequest, GenerationJobAcceptedResponse, GenerationJobError, GenerationJobResponse, GenerationJobStatus, GenerationThreadSummary, PollEditJobOptions, PollRenderProgressOptions, PollGenerationJobOptions, RenderCompositionInput, RenderProgressRequest, RenderProgressResponse, RenderRequest, RenderResponse, GenerateRequest, GenerateResponse, GenerateStreamCallbacks, GenerateStreamMetadata, GenerateStreamResult, RemotionStudioErrorData, RemotionStudioErrorType, ResponseMetadata, } from "./types";

package/dist/sdk/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRemotionStudioClient = exports.RemotionStudioError = exports.stripMarkdownFences = exports.sanitizeGeneratedCode = exports.extractComponentCode = exports.createMotionGraphicsArtifact = exports.MOTION_GRAPHICS_RUNTIME = exports.MOTION_GRAPHICS_ARTIFACT_VERSION = exports.DEFAULT_MOTION_GRAPHICS_WIDTH = exports.DEFAULT_MOTION_GRAPHICS_HEIGHT = exports.DEFAULT_MOTION_GRAPHICS_FPS = exports.DEFAULT_MOTION_GRAPHICS_DURATION_IN_FRAMES = void 0;
+var artifact_1 = require("../shared/artifact");
+Object.defineProperty(exports, "DEFAULT_MOTION_GRAPHICS_DURATION_IN_FRAMES", { enumerable: true, get: function () { return artifact_1.DEFAULT_MOTION_GRAPHICS_DURATION_IN_FRAMES; } });
+Object.defineProperty(exports, "DEFAULT_MOTION_GRAPHICS_FPS", { enumerable: true, get: function () { return artifact_1.DEFAULT_MOTION_GRAPHICS_FPS; } });
+Object.defineProperty(exports, "DEFAULT_MOTION_GRAPHICS_HEIGHT", { enumerable: true, get: function () { return artifact_1.DEFAULT_MOTION_GRAPHICS_HEIGHT; } });
+Object.defineProperty(exports, "DEFAULT_MOTION_GRAPHICS_WIDTH", { enumerable: true, get: function () { return artifact_1.DEFAULT_MOTION_GRAPHICS_WIDTH; } });
+Object.defineProperty(exports, "MOTION_GRAPHICS_ARTIFACT_VERSION", { enumerable: true, get: function () { return artifact_1.MOTION_GRAPHICS_ARTIFACT_VERSION; } });
+Object.defineProperty(exports, "MOTION_GRAPHICS_RUNTIME", { enumerable: true, get: function () { return artifact_1.MOTION_GRAPHICS_RUNTIME; } });
+Object.defineProperty(exports, "createMotionGraphicsArtifact", { enumerable: true, get: function () { return artifact_1.createMotionGraphicsArtifact; } });
+var sanitize_1 = require("../shared/sanitize");
+Object.defineProperty(exports, "extractComponentCode", { enumerable: true, get: function () { return sanitize_1.extractComponentCode; } });
+Object.defineProperty(exports, "sanitizeGeneratedCode", { enumerable: true, get: function () { return sanitize_1.sanitizeGeneratedCode; } });
+Object.defineProperty(exports, "stripMarkdownFences", { enumerable: true, get: function () { return sanitize_1.stripMarkdownFences; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "RemotionStudioError", { enumerable: true, get: function () { return client_1.RemotionStudioError; } });
+Object.defineProperty(exports, "createRemotionStudioClient", { enumerable: true, get: function () { return client_1.createRemotionStudioClient; } });

package/dist/sdk/types.d.ts

@@ -0,0 +1,197 @@
+import type { MotionGraphicsArtifact, MotionGraphicsEditType, MotionGraphicsPresetReference } from "../shared/artifact";
+export type EditOperation = {
+    description: string;
+    old_string: string;
+    new_string: string;
+    lineNumber?: number;
+};
+export type ConversationContextMessage = {
+    role: "user" | "assistant";
+    content: string;
+    attachedImages?: string[];
+};
+export type ErrorCorrectionContext = {
+    error: string;
+    source?: "compilation" | "runtime" | "generation";
+    attemptNumber: number;
+    maxAttempts: number;
+    failedEdit?: EditOperation;
+};
+export type AsyncWebhookCallback = {
+    url: string;
+    headers?: Record<string, string>;
+};
+export type RenderCompositionInput = {
+    code: string;
+    durationInFrames: number;
+    fps: number;
+};
+export type GenerateRequest = {
+    prompt: string;
+    presetId?: string;
+    model?: string;
+    reasoningEffort?: "none" | "low" | "medium" | "high" | "xhigh";
+    frameImages?: string[];
+    streaming?: boolean;
+};
+export type GenerateAsyncRequest = Omit<GenerateRequest, "streaming"> & {
+    webhook?: AsyncWebhookCallback;
+};
+export type EditRequest = {
+    prompt: string;
+    model?: string;
+    reasoningEffort?: "none" | "low" | "medium" | "high" | "xhigh";
+    currentCode: string;
+    threadId?: string;
+    conversationHistory?: ConversationContextMessage[];
+    hasManualEdits?: boolean;
+    errorCorrection?: ErrorCorrectionContext;
+    previouslyUsedSkills?: string[];
+    frameImages?: string[];
+};
+export type EditAsyncRequest = EditRequest & {
+    webhook?: AsyncWebhookCallback;
+};
+export type RenderRequest = {
+    inputProps: RenderCompositionInput;
+    threadId?: string;
+};
+export type RenderResponse = {
+    renderId: string;
+    bucketName: string;
+    cloudWatchLogs: string;
+    cloudWatchMainLogs: string;
+    lambdaInsightsLogs: string;
+    folderInS3Console: string;
+    progressJsonInConsole: string;
+};
+export type RenderProgressRequest = {
+    bucketName: string;
+    id: string;
+};
+export type RenderProgressResponse = {
+    type: "error";
+    message: string;
+} | {
+    type: "progress";
+    progress: number;
+} | {
+    type: "done";
+    url: string;
+    size: number;
+};
+export type PollRenderProgressOptions = {
+    headers?: HeadersInit;
+    intervalMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onUpdate?: (progress: RenderProgressResponse) => void;
+};
+export type ResponseMetadata = {
+    skills: string[];
+    editType: MotionGraphicsEditType;
+    edits?: EditOperation[];
+    model: string;
+    reasoning?: string;
+    preset?: MotionGraphicsPresetReference;
+};
+export type GenerationThreadSummary = {
+    id: string;
+    title: string;
+    messageCount: number;
+    updatedAt: string;
+};
+export type GenerateResponse = {
+    code: string;
+    summary: string;
+    metadata: ResponseMetadata;
+    artifact: MotionGraphicsArtifact;
+    thread?: GenerationThreadSummary;
+};
+export type GenerationJobStatus = "queued" | "processing" | "completed" | "failed";
+export type GenerationJobError = {
+    message: string;
+    type: RemotionStudioErrorType;
+    status?: number;
+    availableCredits?: number;
+    requiredCredits?: number;
+};
+type QueuedJobAcceptedResponse<TRequestType extends "generate" | "edit"> = {
+    id: string;
+    requestType: TRequestType;
+    status: GenerationJobStatus;
+    createdAt: string;
+    pollUrl: string;
+};
+type QueuedJobResponse<TRequestType extends "generate" | "edit", TResult> = {
+    id: string;
+    requestType: TRequestType;
+    status: GenerationJobStatus;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    pollUrl: string;
+    result?: TResult;
+    error?: GenerationJobError;
+};
+export type GenerationJobAcceptedResponse = QueuedJobAcceptedResponse<"generate">;
+export type GenerationJobResponse = QueuedJobResponse<"generate", GenerateResponse>;
+export type EditJobAcceptedResponse = QueuedJobAcceptedResponse<"edit">;
+export type EditJobResponse = QueuedJobResponse<"edit", EditResponse>;
+export type EditResponse = {
+    code: string;
+    summary: string;
+    metadata: ResponseMetadata;
+    artifact: MotionGraphicsArtifact;
+    thread?: GenerationThreadSummary;
+};
+export type FailedEditInfo = {
+    description: string;
+    old_string: string;
+    new_string: string;
+    lineNumber?: number;
+};
+export type RemotionStudioErrorType = "validation" | "api" | "edit_failed" | "authentication" | "authorization" | "insufficient_credits" | "billing_unavailable" | "not_found";
+export type RemotionStudioErrorData = {
+    message: string;
+    type: RemotionStudioErrorType;
+    status?: number;
+    failedEdit?: FailedEditInfo;
+    availableCredits?: number;
+    requiredCredits?: number;
+};
+export type GenerateStreamMetadata = {
+    skills?: string[];
+    model?: string;
+    preset?: MotionGraphicsPresetReference;
+};
+export type GenerateStreamCallbacks = {
+    onMetadata?: (metadata: GenerateStreamMetadata) => void;
+    onReasoningStart?: () => void;
+    onReasoning?: (reasoning: string) => void;
+    onTextStart?: () => void;
+    onCode?: (partialCode: string) => void;
+};
+export type GenerateStreamResult = {
+    code: string;
+    reasoning: string;
+    metadata: GenerateStreamMetadata;
+    summary?: string;
+    artifact?: MotionGraphicsArtifact;
+    thread?: GenerationThreadSummary;
+};
+export type PollGenerationJobOptions = {
+    headers?: HeadersInit;
+    intervalMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onUpdate?: (job: GenerationJobResponse) => void;
+};
+export type PollEditJobOptions = {
+    headers?: HeadersInit;
+    intervalMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onUpdate?: (job: EditJobResponse) => void;
+};
+export {};

package/dist/sdk/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });