ugcinc 4.1.0 → 4.1.2

package/dist/automations/nodes/index.js

@@ -3,9 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeDefinitions = void 0;
+exports.internalNodeTypes = exports.nodeDefinitions = void 0;
 exports.getAllNodeDefinitions = getAllNodeDefinitions;
 exports.getNodeDefinition = getNodeDefinition;
+const internal_1 = require("./internal");
+Object.defineProperty(exports, "internalNodeTypes", { enumerable: true, get: function () { return internal_1.internalNodeTypes; } });
 // Import all node definitions
 const account_1 = __importDefault(require("./account"));
 const auto_caption_1 = __importDefault(require("./auto-caption"));
@@ -37,12 +39,12 @@ const text_1 = __importDefault(require("./text"));
 const transcript_1 = __importDefault(require("./transcript"));
 const video_composer_1 = __importDefault(require("./video-composer"));
 const video_import_1 = __importDefault(require("./video-import"));
+// =============================================================================
+// Registry
+// =============================================================================
 /**
  * Registry of all user-creatable node definitions.
  * This is the single source of truth for node types.
- *
- * Note: Internal executor types like 'for-each-value' are not included here
- * as they are created dynamically during execution, not by users.
  */
 exports.nodeDefinitions = {
     'account': account_1.default,
@@ -76,9 +78,6 @@ exports.nodeDefinitions = {
     'video-composer': video_composer_1.default,
     'video-import': video_import_1.default,
 };
-// =============================================================================
-// Getters
-// =============================================================================
 /**
  * Get all node definitions as an array
  */

package/dist/automations/nodes/internal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Internal Node Types
+ *
+ * These are node types that are created dynamically during execution.
+ * They are not user-creatable and don't have definitions in the nodeDefinitions map.
+ */
+export declare const internalNodeTypes: readonly ["for-each-value"];
+export type InternalNodeType = (typeof internalNodeTypes)[number];

package/dist/automations/nodes/internal.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Internal Node Types
+ *
+ * These are node types that are created dynamically during execution.
+ * They are not user-creatable and don't have definitions in the nodeDefinitions map.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalNodeTypes = void 0;
+exports.internalNodeTypes = ['for-each-value'];

package/dist/automations/nodes/llm.d.ts

@@ -20,8 +20,8 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     apiKeys: LLMApiKeys | undefined;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export { LLMProviders };
 export type { LLMProvider, LLMApiKeys };
-export type LLMConfig = typeof definition.defaults;
+export type LLMNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/manual-trigger.d.ts

@@ -1,34 +1,15 @@
-import type { EnumOption } from '../types';
+import type { BasePortType, EnumOption } from '../types';
 import { type ObjectSchemaField } from './types';
-interface ManualTriggerOutputLocal {
-    id: string;
-    type: string;
-    isArray?: boolean;
-    objectSchema?: ObjectSchemaField[];
-    enumOptions?: EnumOption[];
-}
-/**
- * Manual Trigger node output definition
- */
-export interface ManualTriggerOutput {
-    id: string;
-    type: 'image' | 'video' | 'audio' | 'text' | 'social_audio' | 'account' | 'boolean' | 'object' | 'enum';
-    isArray?: boolean;
-    /** Schema for object types - describes the structure of the object */
-    objectSchema?: ObjectSchemaField[];
-    /** Options for enum types */
-    enumOptions?: EnumOption[];
-}
-/**
- * Manual Trigger node configuration - defines outputs that users provide when running
- */
-export interface ManualTriggerNodeConfig {
-    outputs: ManualTriggerOutput[];
-}
 declare const definition: import("./types").NodeDefinition<"trigger", {
-    outputs: ManualTriggerOutputLocal[];
+    outputs: Array<{
+        id: string;
+        type: BasePortType;
+        isArray?: boolean;
+        objectSchema?: ObjectSchemaField[];
+        enumOptions?: EnumOption[];
+    }>;
     outputMode: null;
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type ManualTriggerConfig = typeof definition.defaults;
+export type ManualTriggerNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/manual-trigger.js

@@ -15,7 +15,7 @@ const definition = (0, types_1.defineNode)({
         selectionMode: null,
     },
     computePorts: ({ config }) => {
-        const configOutputs = (config?.outputs ?? []);
+        const configOutputs = config?.outputs ?? [];
         const outputs = configOutputs.map(output => ({
             id: output.id,
             type: output.type,

package/dist/automations/nodes/media.d.ts

@@ -1,17 +1,14 @@
-import { type SelectionConfig } from './types';
-type MediaNodeEnabledType = 'image' | 'video' | 'audio';
+import { type SelectionConfig, type MediaNodeSelectionType } from './types';
 declare const definition: import("./types").NodeDefinition<"source", {
     outputs: {
         id: string;
-        type: MediaNodeEnabledType;
+        type: MediaNodeSelectionType;
         isArray: boolean;
         selectedMediaIds: string[];
         selectionConfig: SelectionConfig | undefined;
     }[];
     outputMode: "per-input";
     selectionMode: "random";
-}>;
+}, false>;
 export default definition;
-export type { MediaNodeEnabledType };
-export type MediaConfig = typeof definition.defaults;
-export type MediaNodeOutput = MediaConfig['outputs'][number];
+export type MediaNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/not.d.ts

@@ -1,6 +1,6 @@
 declare const definition: import("./types").NodeDefinition<"generator", {
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type NotConfig = typeof definition.defaults;
+export type NotNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/output.d.ts

@@ -1,30 +1,17 @@
+import type { BasePortType } from '../types';
 import { type ObjectSchemaField } from './types';
-/**
- * Output node input definition
- */
 export interface OutputInput {
     id: string;
-    type: 'image' | 'video' | 'audio' | 'text' | 'social_audio' | 'account' | 'boolean' | 'object';
-    /** Individual tag for this input (overrides global tag) */
+    type: BasePortType;
     tag?: string;
-    /** Whether this input accepts an array */
     isArray?: boolean;
-    /** Schema of object properties (when type is object) */
     objectSchema?: ObjectSchemaField[];
 }
-/**
- * Output node configuration
- */
-export interface OutputNodeConfig {
-    inputs: OutputInput[];
-    /** Which input is the main visual preview for the workflow */
-    mainPreviewInputId?: string;
-}
 declare const definition: import("./types").NodeDefinition<"terminal", {
     inputs: OutputInput[];
     mainPreviewInputId: string | undefined;
     outputMode: null;
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type PassthroughConfig = typeof definition.defaults;
+export type OutputNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/random-route.d.ts

@@ -1,52 +1,25 @@
-/**
- * Random Branch branch definition
- */
+import { type InputType } from './types';
 export interface RandomRouteBranch {
-    /** Unique ID for this branch (e.g., "branch-1") */
     id: string;
-    /** Probability weight (0-100, all branches must sum to 100) */
     probability: number;
 }
-/**
- * Object field definition for Random Branch passthrough input default values
- */
 export interface RandomRouteObjectField {
-    /** Field name */
     name: string;
-    /** Field type */
     type: 'string' | 'number' | 'boolean';
 }
-/**
- * Random Branch passthrough input definition
- */
 export interface RandomRoutePassthroughInput {
-    /** The input port ID (lowercase, hyphens/underscores only) */
     id: string;
-    /** The value type */
     type: 'image' | 'video' | 'audio' | 'text' | 'number' | 'boolean' | 'account' | 'object';
-    /** Whether this is an array type */
     isArray?: boolean;
-    /** Whether this input comes from a variable (input port) vs static default value. Defaults to false. */
-    isVariable?: boolean;
-    /** Default value when isVariable is false (type depends on type field) */
+    inputType?: InputType;
     defaultValue?: unknown;
-    /** Object schema for object type (when type is 'object') */
     objectSchema?: RandomRouteObjectField[];
 }
-/**
- * Random Branch node configuration - routes inputs to a randomly selected branch based on probability
- */
-export interface RandomRouteNodeConfig {
-    /** Output branches with probability weights (must sum to 100) */
-    branches: RandomRouteBranch[];
-    /** Passthrough inputs that get routed to one branch's outputs */
-    passthroughInputs: RandomRoutePassthroughInput[];
-}
 declare const definition: import("./types").NodeDefinition<"generator", {
     branches: RandomRouteBranch[];
     passthroughInputs: RandomRoutePassthroughInput[];
     outputMode: "single";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type RandomRouteConfig = typeof definition.defaults;
+export type RandomRouteNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/random-route.js

@@ -15,19 +15,19 @@ const definition = (0, types_1.defineNode)({
             { id: 'branch-2', probability: 50 },
         ],
         passthroughInputs: [
-            { id: 'input', type: 'image', isArray: false, isVariable: false },
+            { id: 'input', type: 'image', isArray: false, inputType: 'static' },
         ],
         outputMode: 'single',
         selectionMode: null,
     },
     computePorts: ({ config }) => {
-        const branches = (config?.branches ?? []);
-        const passthroughInputs = (config?.passthroughInputs ?? []);
+        const branches = config?.branches ?? [];
+        const passthroughInputs = config?.passthroughInputs ?? [];
         const inputs = [];
         const outputs = [];
-        // Input ports: only passthroughs where isVariable is true
+        // Input ports: only passthroughs where inputType is 'variable'
         for (const passthrough of passthroughInputs) {
-            if (passthrough.isVariable) {
+            if (passthrough.inputType === 'variable') {
                 inputs.push({
                     id: passthrough.id,
                     type: passthrough.type,

package/dist/automations/nodes/random.d.ts

@@ -1,7 +1,8 @@
+import { type InputType } from './types';
 export interface RandomInputPort {
     id: string;
     probability: number;
-    isVariable: boolean;
+    inputType: InputType;
     defaultValue?: unknown;
 }
 declare const definition: import("./types").NodeDefinition<"generator", {
@@ -11,6 +12,6 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     inputPorts: RandomInputPort[];
     outputMode: "single";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type RandomConfig = typeof definition.defaults;
+export type RandomNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/random.js

@@ -21,16 +21,16 @@ const definition = (0, types_1.defineNode)({
         const mode = config?.mode ?? 'array';
         const valueType = (config?.valueType ?? 'object');
         const exposeIndex = config?.exposeIndex ?? false;
-        const inputPorts = (config?.inputPorts ?? []);
+        const inputPorts = config?.inputPorts ?? [];
         const inputs = [];
         const outputs = [];
         if (mode === 'array') {
             inputs.push({ id: 'array', type: 'object', isArray: false, required: true });
         }
         else {
-            // Multi-input mode: only add ports where isVariable is true
+            // Multi-input mode: only add ports where inputType is 'variable'
             for (const port of inputPorts) {
-                if (port.isVariable) {
+                if (port.inputType === 'variable') {
                     inputs.push({
                         id: port.id,
                         type: valueType,

package/dist/automations/nodes/recurrence.d.ts

@@ -1,55 +1,16 @@
-import { type TriggerCollectionConfig } from './types';
-/**
- * Days of the week for recurrence scheduling
- */
+import { type TriggerCollectionConfig, type MediaItemType } from './types';
 export type DayOfWeek = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday';
-/**
- * Recurrence media output port definition
- * Each output is a named port with a specific media type and its own selection config
- */
 export interface RecurrenceMediaOutput {
-    /** Unique ID for this output port (e.g., "background-image", "overlay") */
     id: string;
-    /** Media type for this port */
-    type: 'image' | 'video' | 'audio' | 'text' | 'social_audio';
-    /** Selection mode for this output's media source */
+    type: MediaItemType;
     selectionMode: 'specific' | 'by-tag';
-    /** Media IDs for this output (used when selectionMode is 'specific') */
     selectedMediaIds?: string[];
-    /** Tag to query media by at runtime (used when selectionMode is 'by-tag') */
     mediaTag?: string;
 }
-/**
- * Media input configuration for recurrence nodes
- * Each output has its own selection configuration
- */
 export interface RecurrenceMediaConfig {
-    /** Whether media input is enabled */
     enabled: boolean;
-    /** Named output ports - each has its own selection config */
     outputs: RecurrenceMediaOutput[];
 }
-/**
- * Recurrence node configuration - defines when the automation runs on a schedule
- */
-export interface RecurrenceNodeConfig {
-    frequencyType: 'per-day' | 'periodic';
-    runsPerDay: number;
-    periodDays: number;
-    daysOfWeek: DayOfWeek[];
-    timingType: 'specific' | 'random-window';
-    specificTimes: string[];
-    randomWindowStart: string;
-    randomWindowEnd: string;
-    timezone: string;
-    collectionInput?: TriggerCollectionConfig;
-    mediaInput?: RecurrenceMediaConfig;
-}
-/**
- * Recurrence media enabled type
- * Includes all media types that can be output from recurrence nodes
- */
-export type RecurrenceMediaEnabledType = 'image' | 'video' | 'audio' | 'text' | 'social_audio';
 declare const definition: import("./types").NodeDefinition<"trigger", {
     frequencyType: "per-day" | "periodic";
     runsPerDay: number;
@@ -64,6 +25,6 @@ declare const definition: import("./types").NodeDefinition<"trigger", {
     mediaInput: RecurrenceMediaConfig | undefined;
     outputMode: null;
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type RecurrenceConfig = typeof definition.defaults;
+export type RecurrenceNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/recurrence.js

@@ -26,7 +26,7 @@ const definition = (0, types_1.defineNode)({
     },
     computePorts: ({ config }) => {
         const collectionInputEnabled = config?.collectionInput?.enabled;
-        const mediaOutputs = (config?.mediaInput?.outputs ?? []);
+        const mediaOutputs = config?.mediaInput?.outputs ?? [];
         const outputs = [];
         // Add account output if collection input is enabled
         if (collectionInputEnabled) {

package/dist/automations/nodes/save-to-media.d.ts

@@ -1,25 +1,9 @@
-/**
- * Save To Media node input definition
- */
+type SaveToMediaType = 'image' | 'video' | 'audio' | 'text';
 export interface SaveToMediaInput {
     id: string;
-    type: 'image' | 'video' | 'audio' | 'text';
-    /** Optional individual tag for this input (overrides global tag) */
+    type: SaveToMediaType;
     tag?: string;
 }
-/**
- * Save To Media node configuration - saves outputs to media library
- */
-export interface SaveToMediaNodeConfig {
-    /** Dynamic inputs to save */
-    inputs: SaveToMediaInput[];
-    /** Global tag applied to all saved items */
-    globalTag?: string;
-    /** If true, append date in mm-dd-yy format to tag */
-    includeDateTag?: boolean;
-    /** If true, append run ID to make tags unique */
-    makeUnique?: boolean;
-}
 declare const definition: import("./types").NodeDefinition<"terminal", {
     inputs: SaveToMediaInput[];
     globalTag: string | undefined;
@@ -27,6 +11,6 @@ declare const definition: import("./types").NodeDefinition<"terminal", {
     makeUnique: boolean;
     outputMode: null;
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type SaveToMediaConfig = typeof definition.defaults;
+export type SaveToMediaNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/save-to-media.js

@@ -18,7 +18,7 @@ const definition = (0, types_1.defineNode)({
         selectionMode: null,
     },
     computePorts: ({ config }) => {
-        const configInputs = (config?.inputs ?? []);
+        const configInputs = config?.inputs ?? [];
         const inputs = configInputs.map(input => ({
             id: input.id,
             type: input.type,

package/dist/automations/nodes/screenshot-animation.d.ts

@@ -2,6 +2,6 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     holdDurationMs: number;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type ScreenshotAnimationConfig = typeof definition.defaults;
+export type ScreenshotAnimationNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/social-audio.d.ts

@@ -3,6 +3,6 @@ declare const definition: import("./types").NodeDefinition<"source", {
     selectedMediaIds: string[];
     selectionMode: "random";
     outputMode: "per-input";
-}>;
+}, false>;
 export default definition;
-export type SocialAudioConfig = typeof definition.defaults;
+export type SocialAudioNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/text.d.ts

@@ -2,6 +2,6 @@ declare const definition: import("./types").NodeDefinition<"source", {
     textOptions: string[];
     selectionMode: "random";
     outputMode: "per-input";
-}>;
+}, false>;
 export default definition;
-export type TextConfig = typeof definition.defaults;
+export type TextNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/transcript.d.ts

@@ -1,6 +1,6 @@
 declare const definition: import("./types").NodeDefinition<"generator", {
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type TranscriptConfig = typeof definition.defaults;
+export type TranscriptNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/types.d.ts

@@ -5,11 +5,21 @@
  * Each node file imports from here and defines its behavior.
  */
 import type { NodePort, BasePortType } from '../types';
+import type { AutomationsClient } from '../index';
+/** Return type for computePorts - can be sync or async */
+export type ComputePortsResult = {
+    inputs: NodePort[];
+    outputs: NodePort[];
+};
 export type NodeCategory = 'trigger' | 'source' | 'generator' | 'terminal';
 export type OutputMode = 'per-input' | 'single';
 export type SelectionMode = 'random' | 'sequential';
 export type ExhaustionBehavior = 'restart' | 'error';
 export type InputType = 'static' | 'variable';
+/** All possible media item types */
+export type MediaItemType = 'image' | 'video' | 'audio' | 'text' | 'social_audio';
+/** Media types that can be selected from the media node */
+export type MediaNodeSelectionType = 'image' | 'video' | 'audio';
 type PrimitiveType = 'string' | 'number' | 'boolean';
 /**
  * Generic type for object schema fields with compile-time depth enforcement.
@@ -52,15 +62,6 @@ export type SchemaField<CanNestObjects extends boolean = true> = {
 export type ObjectSchemaField = SchemaField<true>;
 /** Nested schema field (inside objectSchema) - arrays can only contain primitives */
 export type NestedSchemaField = SchemaField<false>;
-export interface BranchValueConfig {
-    inputType?: InputType;
-}
-export interface PassthroughInput {
-    id: string;
-    type: string;
-    isArray?: boolean;
-    branchValues?: Record<string, BranchValueConfig>;
-}
 export interface SelectionConfig {
     mode?: SelectionMode;
     enforceUniqueness?: boolean;
@@ -126,26 +127,44 @@ type OutputModesForCategory<T extends NodeCategory> = T extends 'source' | 'gene
  * Computes the selectionModes array type based on node category.
  */
 type SelectionModesForCategory<T extends NodeCategory> = T extends 'source' ? SelectionMode[] : null;
-export interface NodeDefinition<T extends NodeCategory = NodeCategory, TDefaults extends Record<string, unknown> = Record<string, unknown>> {
+/**
+ * Resolved preview data for a node.
+ * Contains render-ready configuration with all references resolved.
+ */
+export interface ResolvedPreview {
+    /** Render-ready config (varies by node type) */
+    renderConfig: unknown;
+    /** Source URLs keyed by segment/element ID */
+    sources: Record<string, string>;
+    /** Text content keyed by segment/element ID */
+    textContent: Record<string, string>;
+}
+export interface NodeDefinition<T extends NodeCategory = NodeCategory, TDefaults extends Record<string, unknown> = Record<string, unknown>, TInternal extends boolean = false> {
     nodeId: string;
     label: string;
     description: string;
     type: T;
     category: string;
+    /** If true, this node is internal and not user-creatable */
+    isInternal: TInternal;
     outputModes: OutputModesForCategory<T>;
     selectionModes: SelectionModesForCategory<T>;
     defaults: DefaultsForCategory<T, TDefaults>;
     computePorts: (params: {
         config: DefaultsForCategory<T, TDefaults>;
+        client?: AutomationsClient;
         getConnectedOutput?: (inputId: string) => {
             type: BasePortType | BasePortType[];
             isArray: boolean;
             objectSchema?: ObjectSchemaField[];
         } | null;
-    }) => {
-        inputs: NodePort[];
-        outputs: NodePort[];
-    };
+    }) => ComputePortsResult | Promise<ComputePortsResult>;
+    /**
+     * Resolve preview values for this node.
+     * Converts config with refs (inputId/textInputId) to render-ready format.
+     * Only implemented by nodes that support preview (image-composer, video-composer).
+     */
+    resolvePreview?: (config: DefaultsForCategory<T, TDefaults>) => ResolvedPreview | null;
 }
 /**
  * Define a node with full type inference.
@@ -154,25 +173,30 @@ export interface NodeDefinition<T extends NodeCategory = NodeCategory, TDefaults
  * - Custom defaults are merged and available in computePorts
  * - No manual type assertions needed
  */
-export declare function defineNode<T extends NodeCategory, TCustomDefaults extends Record<string, unknown>>(def: {
+export declare function defineNode<T extends NodeCategory, TCustomDefaults extends Record<string, unknown>, TInternal extends boolean = false>(def: {
     nodeId: string;
     label: string;
     description: string;
     type: T;
     category: string;
+    /** If true, this node is internal and not user-creatable */
+    isInternal?: TInternal;
     outputModes: OutputModesForCategory<T>;
     selectionModes: SelectionModesForCategory<T>;
     defaults: DefaultsForCategory<T, TCustomDefaults>;
     computePorts: (params: {
         config: DefaultsForCategory<T, TCustomDefaults>;
+        client?: AutomationsClient;
         getConnectedOutput?: (inputId: string) => {
             type: BasePortType | BasePortType[];
             isArray: boolean;
             objectSchema?: ObjectSchemaField[];
         } | null;
-    }) => {
-        inputs: NodePort[];
-        outputs: NodePort[];
-    };
-}): NodeDefinition<T, TCustomDefaults>;
+    }) => ComputePortsResult | Promise<ComputePortsResult>;
+    /**
+     * Resolve preview values for this node.
+     * Converts config with refs (inputId/textInputId) to render-ready format.
+     */
+    resolvePreview?: (config: DefaultsForCategory<T, TCustomDefaults>) => ResolvedPreview | null;
+}): NodeDefinition<T, TCustomDefaults, TInternal>;
 export {};

package/dist/automations/nodes/types.js

@@ -18,5 +18,5 @@ exports.defineNode = defineNode;
  * - No manual type assertions needed
  */
 function defineNode(def) {
-    return def;
+    return { ...def, isInternal: (def.isInternal ?? false) };
 }

package/dist/automations/nodes/video-composer.d.ts

@@ -1,4 +1,3 @@
-import type { VideoEditorNodeConfig } from '../../render/types';
 declare const definition: import("./types").NodeDefinition<"generator", {
     videoEditor: {
         width: number;
@@ -13,13 +12,6 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     };
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type VideoComposerConfig = typeof definition.defaults;
-/**
- * Input to the video-composer node executor
- */
-export interface VideoEditorNodeInput extends Record<string, unknown> {
-    type: 'video-composer';
-    editor: VideoEditorNodeConfig;
-}
+export type VideoComposerNodeConfig = typeof definition.defaults;