@remotion-studio/sdk 0.1.0

package/README.md

@@ -0,0 +1,369 @@
+# Remotion Studio
+
+Generate, edit, play, and render AI-created Remotion compositions from your own apps.
+
+`@remotion-studio/sdk` is the official package for [Remotion Studio](https://remotionstudio.io). It gives you:
+
+- `@remotion-studio/sdk` to call the Remotion Studio API
+- `@remotion-studio/sdk/runtime` to render returned artifacts inside a Remotion project
+
+If you want a visual workflow, use the Remotion Studio UI. If you want to automate generation, build editors, run async jobs, or embed generated scenes in your own product, use the SDK.
+
+With this package you can:
+
+- generate new Remotion compositions from prompts
+- edit compositions through follow-up instructions
+- play returned artifacts directly inside a Remotion app
+- queue long-running async generation or edit jobs
+- start Remotion Lambda renders and track render progress
+- embed the returned artifact directly inside your own Remotion app
+
+## Why Use It
+
+- Generate motion graphics from prompts
+- Edit existing compositions iteratively
+- Play returned artifacts immediately in Remotion
+- Stream generation output
+- Queue long-running jobs and use polling or webhooks
+- Start cloud renders and poll for the final video output
+- Render the returned artifact directly inside Remotion
+
+## Use It Two Ways
+
+### 1. Use the UI
+
+Use [Remotion Studio](https://remotionstudio.io) when you want a visual workflow:
+
+- create and refine compositions in the browser
+- manage prompts, edits, and threads
+- create API tokens for external apps
+
+### 2. Use the API and SDK
+
+Use `@remotion-studio/sdk` when you want to:
+
+- generate compositions from your own app
+- build internal tools or automations
+- trigger async jobs from servers or background workers
+- start Remotion Lambda renders programmatically
+- embed generated artifacts in a Remotion pipeline
+
+## Quick Start
+
+Install:
+
+```bash
+npm install @remotion-studio/sdk
+```
+
+```bash
+pnpm add @remotion-studio/sdk
+```
+
+```bash
+bun add @remotion-studio/sdk
+```
+
+Create a client:
+
+```ts
+import { createRemotionStudioClient } from "@remotion-studio/sdk";
+
+const client = createRemotionStudioClient({
+  baseUrl: "https://your-remotionstudio-domain.com",
+  headers: {
+    Authorization: `Bearer ${process.env.REMOTIONSTUDIO_API_TOKEN}`,
+  },
+});
+```
+
+Generate a composition:
+
+```ts
+const generated = await client.generate({
+  prompt: "A cinematic product hero reveal with dramatic lighting",
+  reasoningEffort: "none",
+});
+```
+
+Edit it:
+
+```ts
+const edited = await client.edit({
+  prompt: "Make it faster, cleaner, and more typography-driven",
+  currentCode: generated.code,
+  threadId: generated.thread?.id,
+});
+```
+
+Use the artifact in Remotion:
+
+```tsx
+import { MotionGraphicsSlot } from "@remotion-studio/sdk/runtime";
+
+export const MyComposition = ({ artifact }: { artifact: any }) => {
+  return <MotionGraphicsSlot artifact={artifact} />;
+};
+```
+
+Start a Remotion Lambda render:
+
+```ts
+const render = await client.render({
+  inputProps: {
+    code: generated.code,
+    durationInFrames: generated.artifact.composition.durationInFrames,
+    fps: generated.artifact.composition.fps,
+  },
+  threadId: generated.thread?.id,
+});
+
+const progress = await client.pollRenderProgress({
+  id: render.renderId,
+  bucketName: render.bucketName,
+});
+```
+
+Successful renders consume `0.1` credit when the final video is returned.
+
+## Getting Access
+
+To use the hosted product, create an account in [Remotion Studio](https://remotionstudio.io).
+
+To generate, edit, or render compositions through the hosted product, you also need active access to Remotion Studio credits or a subscription plan.
+
+For programmatic usage:
+
+1. Sign in to Remotion Studio
+2. Open `Settings -> API Tokens`
+3. Create a token
+4. Use it as a bearer token in the SDK client
+
+The plaintext token is shown only once.
+
+## What The SDK Returns
+
+You do not import generated files directly.
+
+Instead:
+
+1. Call the API with `@remotion-studio/sdk`
+2. Receive a JSON payload containing `artifact`
+3. Pass `artifact` into `@remotion-studio/sdk/runtime`
+
+The artifact is the stable contract between generation and playback.
+
+## Core API
+
+### Generate
+
+```ts
+const generated = await client.generate({
+  prompt: "A clean fintech dashboard animation with sliding cards",
+  reasoningEffort: "high",
+});
+```
+
+#### Presets
+
+Pass a `presetId` to generate compositions using a predefined style template:
+
+```ts
+const generated = await client.generate({
+  prompt: "A product showcase with smooth transitions",
+  presetId: "preset-abc123",
+});
+```
+
+The response includes preset information in the metadata:
+
+```ts
+console.log(generated.metadata.preset);
+// { id: "preset-abc123", name: "Corporate Minimal", source: "builtin" | "custom" }
+```
+
+Presets are created and managed in the Remotion Studio UI. Builtin presets are provided by Remotion Studio. Custom presets are user-created templates that encode style preferences, animation patterns, and design choices.
+
+### Edit
+
+```ts
+const edited = await client.edit({
+  prompt: "Use a brighter palette and add more depth",
+  currentCode: generated.code,
+  threadId: generated.thread?.id,
+});
+```
+
+### Stream
+
+```ts
+const result = await client.generateStream(
+  {
+    prompt: "A kinetic typography intro",
+  },
+  {
+    onMetadata: (metadata) => {
+      console.log(metadata);
+    },
+    onReasoning: (reasoning) => {
+      console.log(reasoning);
+    },
+    onCode: (partialCode) => {
+      console.log(partialCode);
+    },
+  },
+);
+```
+
+## Async Jobs
+
+Use async jobs for:
+
+- high-reasoning generations
+- server-to-server automation
+- long-running edits
+- webhook-driven integrations
+
+Queue a generation:
+
+```ts
+const job = await client.generateAsync({
+  prompt: "A premium SaaS launch video opener",
+  reasoningEffort: "high",
+  webhook: {
+    url: "https://your-app.example.com/remotionstudio/webhook",
+    headers: {
+      Authorization: "Bearer your-app-owned-callback-token",
+    },
+  },
+});
+
+const generated = await client.pollGenerationJob(job.id, {
+  intervalMs: 2000,
+  timeoutMs: 10 * 60 * 1000,
+});
+```
+
+Queue an edit:
+
+```ts
+const job = await client.editAsync({
+  prompt: "Add more contrast and speed up the transitions",
+  currentCode: generated.code,
+  threadId: generated.thread?.id,
+});
+
+const edited = await client.pollEditJob(job.id);
+```
+
+If you provide a webhook, Remotion Studio sends the terminal job payload to your callback URL after completion or failure.
+
+Webhook authentication is handled by caller-provided headers. Remotion Studio forwards those headers when delivering the callback.
+
+There is no built-in webhook signature mechanism.
+
+The recommended pattern is:
+
+```ts
+await client.generateAsync({
+  prompt: "...",
+  webhook: {
+    url: "https://your-app.example.com/remotionstudio/webhook",
+    headers: {
+      Authorization: "Bearer your-app-owned-callback-token",
+    },
+  },
+});
+```
+
+Remotion Studio may include neutral metadata headers such as `X-RemotionStudio-Job-Id` and `X-RemotionStudio-Job-Type`, but it does not sign, mutate, wrap, or replace caller-provided webhook headers.
+
+## Local Dev And Production
+
+The async API contract stays the same across environments:
+
+- local `next dev`: jobs are stored in the database and processed by a local runner
+- Vercel preview/production: jobs are stored in the database and executed through Vercel Workflow
+
+In both cases:
+
+- polling endpoints remain the source of truth
+- webhooks receive the same terminal payload shape
+- transient webhook failures are retried
+
+## Runtime
+
+Use `@remotion-studio/sdk/runtime` when you want to render returned artifacts inside a Remotion project.
+
+```tsx
+import { Composition } from "remotion";
+import {
+  MotionGraphicsComposition,
+  calculateMotionGraphicsMetadata,
+  type MotionGraphicsCompositionProps,
+} from "@remotion-studio/sdk/runtime";
+
+export const RemotionRoot = ({ artifact }: MotionGraphicsCompositionProps) => {
+  return (
+    <Composition
+      id="GeneratedComposition"
+      component={MotionGraphicsComposition}
+      defaultProps={{ artifact }}
+      durationInFrames={180}
+      fps={30}
+      width={1920}
+      height={1080}
+      calculateMetadata={calculateMotionGraphicsMetadata}
+    />
+  );
+};
+```
+
+The runtime expects a normal Remotion project with the peer dependencies installed, including `react`, `remotion`, `three`, `@babel/standalone`, `@remotion/lottie`, `@remotion/shapes`, `@remotion/three`, and `@remotion/transitions`.
+
+## Render API
+
+If your Remotion Studio instance is configured with Remotion Lambda, the SDK also supports:
+
+- `client.render()` to queue a render
+- `client.getRenderProgress()` to fetch the latest render state
+- `client.pollRenderProgress()` to wait until the render completes
+
+The render endpoints return the Remotion Lambda render identifiers and progress state, including the final output URL when rendering is done.
+
+## Model And Credit Notes
+
+The base model is controlled by the Remotion Studio admin. External clients should usually send only `reasoningEffort`.
+Supported `reasoningEffort` values are `none`, `low`, `medium`, `high`, and `xhigh`. Use `none` to explicitly disable reasoning.
+
+Current credit usage is:
+
+- default request or `reasoningEffort: "none"`: 1 credit
+- successful render completion: 0.1 credit
+- `low`: 2 credits
+- `medium`: 3 credits
+- `high`: 4 credits
+- `xhigh`: 5 credits
+
+Legacy clients may still send `model: "provider/model:medium"`, but only the reasoning suffix is used.
+
+## API Docs
+
+If you run your own Remotion Studio instance, the generated API reference is available at:
+
+```text
+https://your-remotionstudio-domain.com/api-docs
+```
+
+## Links
+
+- Website: [remotionstudio.io](https://remotionstudio.io)
+- Product: [Remotion Studio](https://remotionstudio.io)
+- Repository: [github.com/prismosoft/remotionstudio](https://github.com/prismosoft/remotionstudio)
+
+## Package Exports
+
+```ts
+import { createRemotionStudioClient } from "@remotion-studio/sdk";
+import { MotionGraphicsSlot } from "@remotion-studio/sdk/runtime";
+```

package/dist/runtime/compiler.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { MotionGraphicsArtifact } from "../shared/artifact";
+export interface CompilationResult {
+    Component: React.ComponentType<Record<string, unknown>> | null;
+    error: string | null;
+}
+export declare function compileMotionGraphicsArtifact(artifact: MotionGraphicsArtifact): CompilationResult;

package/dist/runtime/compiler.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileMotionGraphicsArtifact = compileMotionGraphicsArtifact;
+const Babel = __importStar(require("@babel/standalone"));
+const lottie_1 = require("@remotion/lottie");
+const RemotionShapes = __importStar(require("@remotion/shapes"));
+const three_1 = require("@remotion/three");
+const transitions_1 = require("@remotion/transitions");
+const clock_wipe_1 = require("@remotion/transitions/clock-wipe");
+const fade_1 = require("@remotion/transitions/fade");
+const flip_1 = require("@remotion/transitions/flip");
+const slide_1 = require("@remotion/transitions/slide");
+const wipe_1 = require("@remotion/transitions/wipe");
+const react_1 = __importStar(require("react"));
+const remotion_1 = require("remotion");
+const THREE = __importStar(require("three"));
+const compilationCache = new Map();
+function stripImportStatements(code) {
+    let cleaned = code;
+    cleaned = cleaned.replace(/import\s+type\s*\{[\s\S]*?\}\s*from\s*["'][^"']+["'];?/g, "");
+    cleaned = cleaned.replace(/import\s+\w+\s*,\s*\{[\s\S]*?\}\s*from\s*["'][^"']+["'];?/g, "");
+    cleaned = cleaned.replace(/import\s*\{[\s\S]*?\}\s*from\s*["'][^"']+["'];?/g, "");
+    cleaned = cleaned.replace(/import\s+\*\s+as\s+\w+\s+from\s*["'][^"']+["'];?/g, "");
+    cleaned = cleaned.replace(/import\s+\w+\s+from\s*["'][^"']+["'];?/g, "");
+    cleaned = cleaned.replace(/import\s*["'][^"']+["'];?/g, "");
+    return cleaned.trim();
+}
+function getExportedComponentName(code) {
+    const match = code.match(/export\s+const\s+(\w+)/);
+    return match?.[1] ?? null;
+}
+function buildExecutableSource(code) {
+    const cleaned = stripImportStatements(code);
+    const componentName = getExportedComponentName(cleaned);
+    if (!componentName) {
+        throw new Error('Code must export a component using `export const ComponentName = ...`.');
+    }
+    const executableSource = cleaned.replace(/export\s+const\s+(\w+)/, "const $1");
+    return {
+        executableSource,
+        componentName,
+    };
+}
+function createCompilationError(message) {
+    return {
+        Component: null,
+        error: message,
+    };
+}
+function compileMotionGraphicsArtifact(artifact) {
+    const code = artifact.code?.trim();
+    if (!code) {
+        return createCompilationError("No code provided");
+    }
+    const cached = compilationCache.get(code);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const { executableSource, componentName } = buildExecutableSource(code);
+        const transpiled = Babel.transform(executableSource, {
+            presets: ["react", "typescript"],
+            filename: "motion-graphics-artifact.tsx",
+        });
+        if (!transpiled.code) {
+            const result = createCompilationError("Transpilation failed");
+            compilationCache.set(code, result);
+            return result;
+        }
+        const wrappedCode = `${transpiled.code}\nreturn ${componentName};`;
+        const createComponent = new Function("React", "Remotion", "RemotionShapes", "Lottie", "ThreeCanvas", "THREE", "AbsoluteFill", "interpolate", "useCurrentFrame", "useVideoConfig", "spring", "Sequence", "Img", "useState", "useEffect", "useMemo", "useRef", "Rect", "Circle", "Triangle", "Star", "Polygon", "Ellipse", "Heart", "Pie", "makeRect", "makeCircle", "makeTriangle", "makeStar", "makePolygon", "makeEllipse", "makeHeart", "makePie", "TransitionSeries", "linearTiming", "springTiming", "fade", "slide", "wipe", "flip", "clockWipe", wrappedCode);
+        const Component = createComponent(react_1.default, {
+            AbsoluteFill: remotion_1.AbsoluteFill,
+            interpolate: remotion_1.interpolate,
+            useCurrentFrame: remotion_1.useCurrentFrame,
+            useVideoConfig: remotion_1.useVideoConfig,
+            spring: remotion_1.spring,
+            Sequence: remotion_1.Sequence,
+            Img: remotion_1.Img,
+        }, RemotionShapes, lottie_1.Lottie, three_1.ThreeCanvas, THREE, remotion_1.AbsoluteFill, remotion_1.interpolate, remotion_1.useCurrentFrame, remotion_1.useVideoConfig, remotion_1.spring, remotion_1.Sequence, remotion_1.Img, react_1.useState, react_1.useEffect, react_1.useMemo, react_1.useRef, RemotionShapes.Rect, RemotionShapes.Circle, RemotionShapes.Triangle, RemotionShapes.Star, RemotionShapes.Polygon, RemotionShapes.Ellipse, RemotionShapes.Heart, RemotionShapes.Pie, RemotionShapes.makeRect, RemotionShapes.makeCircle, RemotionShapes.makeTriangle, RemotionShapes.makeStar, RemotionShapes.makePolygon, RemotionShapes.makeEllipse, RemotionShapes.makeHeart, RemotionShapes.makePie, transitions_1.TransitionSeries, transitions_1.linearTiming, transitions_1.springTiming, fade_1.fade, slide_1.slide, wipe_1.wipe, flip_1.flip, clock_wipe_1.clockWipe);
+        if (typeof Component !== "function") {
+            const result = createCompilationError("Code must export a React component function");
+            compilationCache.set(code, result);
+            return result;
+        }
+        const result = {
+            Component: Component,
+            error: null,
+        };
+        compilationCache.set(code, result);
+        return result;
+    }
+    catch (error) {
+        const result = createCompilationError(error instanceof Error ? error.message : "Unknown compilation error");
+        compilationCache.set(code, result);
+        return result;
+    }
+}

package/dist/runtime/components.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { MotionGraphicsCompositionProps } from "../shared/artifact";
+export declare const MotionGraphicsComposition: React.FC<MotionGraphicsCompositionProps>;
+export declare const MotionGraphicsSlot: React.FC<MotionGraphicsCompositionProps>;

package/dist/runtime/components.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MotionGraphicsSlot = exports.MotionGraphicsComposition = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const remotion_1 = require("remotion");
+const compiler_1 = require("./compiler");
+const RuntimeErrorDisplay = ({ error }) => {
+    return ((0, jsx_runtime_1.jsxs)(remotion_1.AbsoluteFill, { style: {
+            backgroundColor: "#1a1a2e",
+            justifyContent: "center",
+            alignItems: "center",
+            padding: 60,
+        }, children: [(0, jsx_runtime_1.jsx)("div", { style: {
+                    color: "#ff6b6b",
+                    fontSize: 42,
+                    fontFamily: "system-ui, sans-serif",
+                    textAlign: "center",
+                    maxWidth: "80%",
+                }, children: "Compilation Error" }), (0, jsx_runtime_1.jsx)("div", { style: {
+                    color: "#fff",
+                    fontSize: 24,
+                    fontFamily: "monospace",
+                    marginTop: 24,
+                    textAlign: "center",
+                    maxWidth: "80%",
+                    wordBreak: "break-word",
+                }, children: error })] }));
+};
+const MotionGraphicsRenderer = ({ artifact, componentProps, }) => {
+    const result = (0, react_1.useMemo)(() => (0, compiler_1.compileMotionGraphicsArtifact)(artifact), [artifact.code]);
+    if (result.error) {
+        return (0, jsx_runtime_1.jsx)(RuntimeErrorDisplay, { error: result.error });
+    }
+    if (!result.Component) {
+        return null;
+    }
+    const Component = result.Component;
+    return (0, jsx_runtime_1.jsx)(Component, { ...(componentProps ?? {}) });
+};
+const MotionGraphicsComposition = (props) => {
+    return (0, jsx_runtime_1.jsx)(MotionGraphicsRenderer, { ...props });
+};
+exports.MotionGraphicsComposition = MotionGraphicsComposition;
+const MotionGraphicsSlot = (props) => {
+    return (0, jsx_runtime_1.jsx)(MotionGraphicsRenderer, { ...props });
+};
+exports.MotionGraphicsSlot = MotionGraphicsSlot;

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+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, calculateMotionGraphicsMetadata, type MotionGraphicsArtifact, type MotionGraphicsArtifactV1, type MotionGraphicsCompositionProps, type MotionGraphicsEditType, } from "../shared/artifact";
+export { MotionGraphicsComposition, MotionGraphicsSlot } from "./components";
+export { compileMotionGraphicsArtifact, type CompilationResult, } from "./compiler";

package/dist/runtime/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileMotionGraphicsArtifact = exports.MotionGraphicsSlot = exports.MotionGraphicsComposition = exports.calculateMotionGraphicsMetadata = 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, "calculateMotionGraphicsMetadata", { enumerable: true, get: function () { return artifact_1.calculateMotionGraphicsMetadata; } });
+var components_1 = require("./components");
+Object.defineProperty(exports, "MotionGraphicsComposition", { enumerable: true, get: function () { return components_1.MotionGraphicsComposition; } });
+Object.defineProperty(exports, "MotionGraphicsSlot", { enumerable: true, get: function () { return components_1.MotionGraphicsSlot; } });
+var compiler_1 = require("./compiler");
+Object.defineProperty(exports, "compileMotionGraphicsArtifact", { enumerable: true, get: function () { return compiler_1.compileMotionGraphicsArtifact; } });

package/dist/sdk/client.d.ts

@@ -0,0 +1,37 @@
+import { createMotionGraphicsArtifact, type MotionGraphicsArtifact } from "../shared/artifact";
+import type { EditAsyncRequest, EditJobAcceptedResponse, EditJobResponse, EditRequest, EditResponse, GenerateAsyncRequest, GenerationJobAcceptedResponse, GenerationJobResponse, PollEditJobOptions, PollRenderProgressOptions, GenerateRequest, GenerateResponse, PollGenerationJobOptions, GenerateStreamCallbacks, GenerateStreamResult, RenderProgressRequest, RenderProgressResponse, RenderRequest, RenderResponse, RemotionStudioErrorData, RemotionStudioErrorType } from "./types";
+type FetchLike = typeof fetch;
+type CreateRemotionStudioClientOptions = {
+    baseUrl?: string;
+    fetch?: FetchLike;
+    headers?: HeadersInit;
+};
+type RequestOptions = {
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+};
+export declare class RemotionStudioError extends Error {
+    readonly type: RemotionStudioErrorType;
+    readonly status?: number;
+    readonly failedEdit?: RemotionStudioErrorData["failedEdit"];
+    readonly availableCredits?: number;
+    readonly requiredCredits?: number;
+    constructor(data: RemotionStudioErrorData);
+}
+export declare const createRemotionStudioClient: ({ baseUrl, fetch: providedFetch, headers: defaultHeaders, }?: CreateRemotionStudioClientOptions) => {
+    generate(request: GenerateRequest, options?: RequestOptions): Promise<GenerateResponse>;
+    edit(request: EditRequest, options?: RequestOptions): Promise<EditResponse>;
+    generateAsync(request: GenerateAsyncRequest, options?: RequestOptions): Promise<GenerationJobAcceptedResponse>;
+    editAsync(request: EditAsyncRequest, options?: RequestOptions): Promise<EditJobAcceptedResponse>;
+    getGenerationJob(jobId: string, options?: RequestOptions): Promise<GenerationJobResponse>;
+    getEditJob(jobId: string, options?: RequestOptions): Promise<EditJobResponse>;
+    pollGenerationJob(jobId: string, options?: PollGenerationJobOptions): Promise<GenerateResponse>;
+    pollEditJob(jobId: string, options?: PollEditJobOptions): Promise<EditResponse>;
+    render(request: RenderRequest, options?: RequestOptions): Promise<RenderResponse>;
+    getRenderProgress(request: RenderProgressRequest, options?: RequestOptions): Promise<RenderProgressResponse>;
+    pollRenderProgress(request: RenderProgressRequest, options?: PollRenderProgressOptions): Promise<Extract<RenderProgressResponse, {
+        type: "done";
+    }>>;
+    generateStream(request: GenerateRequest, callbacks?: GenerateStreamCallbacks, options?: RequestOptions): Promise<GenerateStreamResult>;
+};
+export { createMotionGraphicsArtifact, type MotionGraphicsArtifact, };