ugcinc 4.1.0 → 4.1.2

package/dist/automations/nodes/create-dm.js

@@ -11,71 +11,69 @@ const definition = (0, types_1.defineNode)({
     selectionModes: null,
     defaults: {
         platform: 'instagram',
-        platformIsVariable: false,
+        platformInputType: 'static',
         lightMode: true,
-        lightModeIsVariable: false,
+        lightModeInputType: 'static',
         username: '',
-        usernameIsVariable: false,
+        usernameInputType: 'static',
         time: '9:41',
-        timeIsVariable: false,
+        timeInputType: 'static',
         profilePicUrl: 'https://ugcinc.co/logo.png',
-        profilePicIsVariable: false,
-        messagesIsVariable: false,
+        profilePicInputType: 'static',
         messages: [
             { sender: 'user', text: 'Wow, this dm automation is realistic right 🤯' },
             { sender: 'recipient', text: "I know, it's like we're really in imessage" },
             { sender: 'recipient', text: 'Just be thankful we\'re not on android 😭😭😭' },
         ],
+        messagesInputType: 'static',
         imageAttachmentUrl: undefined,
-        imageAttachmentIsVariable: false,
-        imessage: {
-            senderBubbleColor: undefined,
-            showReadReceipt: false,
-            readReceiptText: 'Read',
-            readReceiptTimeIsVariable: false,
-            unreadBadgeText: '67',
-            unreadBadgeIsVariable: false,
-            messageHeaderTimestampText: '',
-            messageHeaderTimeIsVariable: false,
-        },
-        instagram: {
-            userHasStory: false,
-        },
+        imageAttachmentInputType: 'static',
+        // iMessage-specific
+        imessageSenderBubbleColor: undefined,
+        imessageShowReadReceipt: false,
+        imessageReadReceiptText: 'Read',
+        imessageReadReceiptTimeInputType: 'static',
+        imessageUnreadBadgeText: '67',
+        imessageUnreadBadgeInputType: 'static',
+        imessageMessageHeaderTimestampText: '',
+        imessageMessageHeaderTimeInputType: 'static',
+        // Instagram-specific
+        instagramUserHasStory: false,
         outputMode: 'per-input',
         selectionMode: null,
     },
     computePorts: ({ config }) => {
         const inputs = [];
-        if (config?.platformIsVariable) {
+        if (config?.platformInputType === 'variable') {
             inputs.push({ id: 'platform', type: 'text', isArray: false, required: true });
         }
-        if (config?.lightModeIsVariable) {
+        if (config?.lightModeInputType === 'variable') {
             inputs.push({ id: 'light-mode', type: 'boolean', isArray: false, required: false });
         }
-        if (config?.usernameIsVariable) {
+        if (config?.usernameInputType === 'variable') {
             inputs.push({ id: 'username', type: 'text', isArray: false, required: true });
         }
-        if (config?.timeIsVariable) {
+        if (config?.timeInputType === 'variable') {
             inputs.push({ id: 'time', type: 'text', isArray: false, required: false });
         }
-        if (config?.profilePicIsVariable) {
+        if (config?.profilePicInputType === 'variable') {
             inputs.push({ id: 'profile-pic', type: 'image', isArray: false, required: false });
         }
-        if (config?.messagesIsVariable) {
+        if (config?.messagesInputType === 'variable') {
             inputs.push({ id: 'messages', type: 'object', isArray: true, required: true });
         }
-        if (config?.imageAttachmentIsVariable) {
+        if (config?.imageAttachmentInputType === 'variable') {
             inputs.push({ id: 'image-attachment', type: 'image', isArray: false, required: false });
         }
         // iMessage-specific
         if (config?.platform === 'imessage') {
-            if (config.imessage?.showReadReceipt && config.imessage?.readReceiptTimeIsVariable) {
+            if (config.imessageShowReadReceipt && config.imessageReadReceiptTimeInputType === 'variable') {
                 inputs.push({ id: 'read-receipt-time', type: 'text', isArray: false, required: false });
             }
-            if (config.imessage?.unreadBadgeIsVariable) {
+            if (config.imessageUnreadBadgeInputType === 'variable') {
                 inputs.push({ id: 'unread-badge', type: 'text', isArray: false, required: false });
             }
-            if (config.imessage?.messageHeaderTimeIsVariable) {
+            if (config.imessageMessageHeaderTimeInputType === 'variable') {
                 inputs.push({ id: 'message-header-time', type: 'text', isArray: false, required: false });
             }
         }

package/dist/automations/nodes/custom-model.d.ts

@@ -1,5 +1,5 @@
-type CustomModelOutputType = 'image' | 'video' | 'audio';
-interface CustomModelInputParam {
+export type CustomModelOutputType = 'image' | 'video' | 'audio';
+export interface CustomModelInputParam {
     name: string;
     type: string;
     required: boolean;
@@ -14,6 +14,6 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     apiKey: string | undefined;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type CustomModelConfig = typeof definition.defaults;
+export type CustomModelNodeConfig = typeof definition.defaults;

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

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

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

@@ -1,3 +1,4 @@
+import { type InputType } from './types';
 type IndexExpression = {
     type: 'single';
     index: number;
@@ -12,14 +13,14 @@ type IndexExpression = {
 interface DestructureSelection {
     portId: string;
     indexExpr: IndexExpression;
-    isVariable?: boolean;
+    inputType?: InputType;
     propertyPath?: string;
 }
 declare const definition: import("./types").NodeDefinition<"generator", {
     selections: DestructureSelection[];
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export type { DestructureSelection, IndexExpression };
-export type DestructureConfig = typeof definition.defaults;
+export type DestructureNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/destructure.js

@@ -40,7 +40,7 @@ const definition = (0, types_1.defineNode)({
         }
         for (const selection of selections) {
             // If variable, add input port for index expression
-            if (selection.isVariable) {
+            if (selection.inputType === 'variable') {
                 inputs.push({
                     id: `idx-${selection.portId}`,
                     type: 'text',

package/dist/automations/nodes/for-each.d.ts

@@ -17,7 +17,7 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     exposeIndex: boolean;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export type { ForEachOutputProperty, ForEachInputPort };
-export type ForEachConfig = typeof definition.defaults;
+export type ForEachNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/generate-image.d.ts

@@ -9,8 +9,8 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     apiKey: string | undefined;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export { isEditModel };
 export type { ImageGenerationTextModel, ImageGenerationEditModel, ImageGenerationModel };
-export type GenerateImageConfig = typeof definition.defaults;
+export type GenerateImageNodeConfig = typeof definition.defaults;

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

@@ -9,8 +9,8 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     apiKey: string | undefined;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export { isImageToVideoModel };
 export type { VideoGenerationTextToVideoModel, VideoGenerationImageToVideoModel, VideoGenerationModel };
-export type GenerateVideoConfig = typeof definition.defaults;
+export type GenerateVideoNodeConfig = typeof definition.defaults;

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

@@ -15,8 +15,8 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     passthroughInputs: IfPassthroughInput[];
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export { IfLogicOperators };
 export type { IfLogicOperator, IfBooleanInput, IfPassthroughInput };
-export type IfConfig = typeof definition.defaults;
+export type IfNodeConfig = typeof definition.defaults;

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

@@ -1,5 +1,36 @@
-import type { NodeOutputValues } from '../types';
-import type { ImageEditorNodeConfig } from '../../render/types';
+import type { ImageEditorElement, DimensionPresetKey, FitMode, DynamicCropConfig } from '../../render/types';
+/**
+ * Image editor node configuration
+ *
+ * This is the complete configuration for an image editor node,
+ * including canvas dimensions, elements, and crop settings.
+ */
+export interface ImageEditorNodeConfig {
+    /** Canvas width in pixels */
+    width: number;
+    /** Canvas height in pixels */
+    height: number;
+    /** Aspect ratio string (e.g., "9:16") */
+    aspectRatio: string;
+    /** Dimension preset key */
+    dimensionPreset: DimensionPresetKey;
+    /** Elements to render */
+    elements: ImageEditorElement[];
+    /** Background type: 'image' for image input, 'color' for solid color */
+    backgroundType?: 'image' | 'color';
+    /** Background color (hex) when backgroundType is 'color' */
+    backgroundColor?: string;
+    /** How the background image fits the canvas */
+    backgroundFit?: FitMode;
+    /** Cached background image URL for consistent preview */
+    previewBackgroundUrl?: string;
+    /** Cached image URLs for image elements (keyed by inputId) */
+    previewImageUrls?: Record<string, string>;
+    /** Cached text values for text elements (keyed by textInputId) */
+    previewTextValues?: Record<string, string>;
+    /** Dynamic cropping configuration */
+    dynamicCrop?: DynamicCropConfig;
+}
 declare const definition: import("./types").NodeDefinition<"generator", {
     imageEditor: {
         width: number;
@@ -11,23 +42,6 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     };
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type ImageComposerConfig = typeof definition.defaults;
-/**
- * Input to the image-composer node executor
- */
-export interface ImageEditorNodeInput extends Record<string, unknown> {
-    type: 'image-composer';
-    config: ImageEditorNodeConfig;
-    imageUrls: Record<string, string>;
-    textValues: Record<string, string>;
-}
-/**
- * Output from the image-composer node executor
- */
-export interface ImageEditorNodeOutput extends Record<string, unknown>, NodeOutputValues {
-    width?: number;
-    height?: number;
-    aspectRatio?: string;
-}
+export type ImageComposerNodeConfig = typeof definition.defaults;

package/dist/automations/nodes/image-composer.js

@@ -91,5 +91,45 @@ const definition = (0, types_1.defineNode)({
             ],
         };
     },
+    resolvePreview: (config) => {
+        const editorConfig = config?.imageEditor;
+        if (!editorConfig)
+            return null;
+        const sources = {};
+        const textContent = {};
+        // Add background URL if available
+        if (editorConfig.previewBackgroundUrl) {
+            sources['background'] = editorConfig.previewBackgroundUrl;
+        }
+        // Resolve image elements: inputId -> element.id
+        // Resolve text elements: textInputId -> element.id
+        for (const elem of editorConfig.elements) {
+            if (elem.type === 'image' && elem.inputId) {
+                const url = editorConfig.previewImageUrls?.[elem.inputId];
+                if (url) {
+                    sources[elem.id] = url;
+                }
+            }
+            else if (elem.type === 'text' && elem.textInputId) {
+                const text = editorConfig.previewTextValues?.[elem.textInputId];
+                if (text) {
+                    textContent[elem.id] = text;
+                }
+            }
+        }
+        return {
+            renderConfig: {
+                elements: editorConfig.elements,
+                width: editorConfig.width,
+                height: editorConfig.height,
+                backgroundType: editorConfig.backgroundType,
+                backgroundColor: editorConfig.backgroundColor,
+                backgroundFit: editorConfig.backgroundFit,
+                dynamicCrop: editorConfig.dynamicCrop,
+            },
+            sources,
+            textContent,
+        };
+    },
 });
 exports.default = definition;

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

@@ -1,14 +1,307 @@
-import type { UserCreatableNodeType } from '../types';
 import type { NodeDefinition } from './types';
-type AnyNodeDefinition = NodeDefinition<any, any>;
+import { internalNodeTypes, type InternalNodeType } from './internal';
 /**
  * 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.
  */
-export declare const nodeDefinitions: Record<UserCreatableNodeType, AnyNodeDefinition>;
+export declare const nodeDefinitions: {
+    readonly account: NodeDefinition<"source", {
+        accountIds: string[];
+        outputMode: "per-input";
+        selectionMode: "random";
+    }, false>;
+    readonly 'auto-caption': NodeDefinition<"generator", {
+        preset: import("./auto-caption").AutoCaptionPreset;
+        fontName: string | undefined;
+        fontSize: number | undefined;
+        fontWeight: import("./auto-caption").AutoCaptionFontWeight | undefined;
+        fontColor: string | undefined;
+        highlightColor: string | undefined;
+        strokeColor: string | undefined;
+        strokeWidth: number | undefined;
+        backgroundColor: string | undefined;
+        position: import("./auto-caption").AutoCaptionPosition | undefined;
+        yOffset: number | undefined;
+        maxWidth: number | undefined;
+        wordsPerSubtitle: number | undefined;
+        enableAnimation: boolean | undefined;
+        language: string | undefined;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'auto-post': NodeDefinition<"terminal", {
+        mode: import("./auto-post").AutoPostMode;
+        inputType: import("./types").InputType;
+        imageInputs: Array<{
+            id: string;
+        }>;
+        socialAudioIsVariable: boolean;
+        socialAudioSelectedIds: string[];
+        schedulingMode: import("./auto-post").PostSchedulingMode;
+        minDistanceHours: number;
+        maxPostsPerDay: number;
+        randomWindowStart: string;
+        randomWindowEnd: string;
+        timezone: string;
+        requireApproval: boolean;
+        outputMode: null;
+        selectionMode: null;
+    }, false>;
+    readonly branch: NodeDefinition<"generator", {
+        branches: import("./branch").BranchDefinition[];
+        passthroughInputs: import("./branch").PassthroughInput[];
+        defaultBranchKey: string;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly collect: NodeDefinition<"generator", {
+        expectedCount: number | undefined;
+        forEachTemplateId: string | undefined;
+        outputMode: "single";
+        selectionMode: null;
+    }, false>;
+    readonly 'compose-workflow': NodeDefinition<"generator", {
+        workflowTemplateId: string | undefined;
+        resolvedPorts: import("../types").ResolvedPorts | undefined;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'create-dm': NodeDefinition<"generator", {
+        platform: import("./create-dm").DmPlatform;
+        platformInputType: import("./types").InputType;
+        lightMode: boolean;
+        lightModeInputType: import("./types").InputType;
+        username: string;
+        usernameInputType: import("./types").InputType;
+        time: string;
+        timeInputType: import("./types").InputType;
+        profilePicUrl: string;
+        profilePicInputType: import("./types").InputType;
+        messages: import("./create-dm").CreateDmMessage[];
+        messagesInputType: import("./types").InputType;
+        imageAttachmentUrl: string | undefined;
+        imageAttachmentInputType: import("./types").InputType;
+        imessageSenderBubbleColor: string | undefined;
+        imessageShowReadReceipt: boolean;
+        imessageReadReceiptText: string;
+        imessageReadReceiptTimeInputType: import("./types").InputType;
+        imessageUnreadBadgeText: string;
+        imessageUnreadBadgeInputType: import("./types").InputType;
+        imessageMessageHeaderTimestampText: string;
+        imessageMessageHeaderTimeInputType: import("./types").InputType;
+        instagramUserHasStory: boolean;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'custom-model': NodeDefinition<"generator", {
+        modelId: string;
+        modelName: string;
+        outputType: import("./custom-model").CustomModelOutputType;
+        inputParams: import("./custom-model").CustomModelInputParam[];
+        apiKey: string | undefined;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly deduplicate: NodeDefinition<"generator", {
+        deduplication: import("../../render").DeduplicationLevel;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly destructure: NodeDefinition<"generator", {
+        selections: import("./destructure").DestructureSelection[];
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'for-each': NodeDefinition<"generator", {
+        outputProperties: import("./for-each").ForEachOutputProperty[];
+        inputPorts: import("./for-each").ForEachInputPort[];
+        exposeItem: boolean;
+        exposeIndex: boolean;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'generate-image': NodeDefinition<"generator", {
+        model: import("./generate-image").ImageGenerationModel;
+        aspectRatio: string;
+        numImages: number;
+        apiKey: string | undefined;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'generate-video': NodeDefinition<"generator", {
+        model: import("./generate-video").VideoGenerationModel;
+        aspectRatio: string;
+        duration: number;
+        apiKey: string | undefined;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly if: NodeDefinition<"generator", {
+        logicOperator: import("./if").IfLogicOperator;
+        booleanInputs: import("./if").IfBooleanInput[];
+        passthroughInputs: import("./if").IfPassthroughInput[];
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'image-composer': NodeDefinition<"generator", {
+        imageEditor: {
+            width: number;
+            height: number;
+            aspectRatio: string;
+            dimensionPreset: string;
+            backgroundType: string;
+            elements: never[];
+        };
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly llm: NodeDefinition<"generator", {
+        provider: import("./llm").LLMProvider;
+        model: string;
+        temperature: number;
+        maxTokens: number | undefined;
+        systemPrompt: string;
+        outputFields: import("./types").ObjectSchemaField[];
+        useStructuredOutput: boolean;
+        imageInputRefs: string[];
+        videoInputRefs: string[];
+        apiKeys: import("./llm").LLMApiKeys | undefined;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'manual-trigger': NodeDefinition<"trigger", {
+        outputs: Array<{
+            id: string;
+            type: import("../types").BasePortType;
+            isArray?: boolean;
+            objectSchema?: import("./types").ObjectSchemaField[];
+            enumOptions?: import("../types").EnumOption[];
+        }>;
+        outputMode: null;
+        selectionMode: null;
+    }, false>;
+    readonly media: NodeDefinition<"source", {
+        outputs: {
+            id: string;
+            type: import("./types").MediaNodeSelectionType;
+            isArray: boolean;
+            selectedMediaIds: string[];
+            selectionConfig: import("./types").SelectionConfig | undefined;
+        }[];
+        outputMode: "per-input";
+        selectionMode: "random";
+    }, false>;
+    readonly not: NodeDefinition<"generator", {
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly passthrough: NodeDefinition<"terminal", {
+        inputs: import("./output").OutputInput[];
+        mainPreviewInputId: string | undefined;
+        outputMode: null;
+        selectionMode: null;
+    }, false>;
+    readonly random: NodeDefinition<"generator", {
+        mode: "array" | "multi-input";
+        valueType: string;
+        exposeIndex: boolean;
+        inputPorts: import("./random").RandomInputPort[];
+        outputMode: "single";
+        selectionMode: null;
+    }, false>;
+    readonly 'random-route': NodeDefinition<"generator", {
+        branches: import("./random-route").RandomRouteBranch[];
+        passthroughInputs: import("./random-route").RandomRoutePassthroughInput[];
+        outputMode: "single";
+        selectionMode: null;
+    }, false>;
+    readonly recurrence: NodeDefinition<"trigger", {
+        frequencyType: "per-day" | "periodic";
+        runsPerDay: number;
+        periodDays: number;
+        daysOfWeek: import("./recurrence").DayOfWeek[];
+        timingType: "specific" | "random-window";
+        specificTimes: string[];
+        randomWindowStart: string;
+        randomWindowEnd: string;
+        timezone: string;
+        collectionInput: import("./types").TriggerCollectionConfig | undefined;
+        mediaInput: import("./recurrence").RecurrenceMediaConfig | undefined;
+        outputMode: null;
+        selectionMode: null;
+    }, false>;
+    readonly 'save-to-media': NodeDefinition<"terminal", {
+        inputs: import("./save-to-media").SaveToMediaInput[];
+        globalTag: string | undefined;
+        includeDateTag: boolean;
+        makeUnique: boolean;
+        outputMode: null;
+        selectionMode: null;
+    }, false>;
+    readonly 'screenshot-animation': NodeDefinition<"generator", {
+        holdDurationMs: number;
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'social-audio': NodeDefinition<"source", {
+        urls: string[];
+        selectedMediaIds: string[];
+        selectionMode: "random";
+        outputMode: "per-input";
+    }, false>;
+    readonly text: NodeDefinition<"source", {
+        textOptions: string[];
+        selectionMode: "random";
+        outputMode: "per-input";
+    }, false>;
+    readonly transcript: NodeDefinition<"generator", {
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'video-composer': NodeDefinition<"generator", {
+        videoEditor: {
+            width: number;
+            height: number;
+            fps: number;
+            dimensionPreset: string;
+            channels: {
+                id: string;
+                name: string;
+                segments: never[];
+            }[];
+        };
+        outputMode: "per-input";
+        selectionMode: null;
+    }, false>;
+    readonly 'video-import': NodeDefinition<"source", {
+        platform: import("./video-import").VideoImportPlatform;
+        videoQuality: import("./video-import").VideoImportQuality;
+        outputMode: "per-input";
+        selectionMode: "random";
+    }, false>;
+};
+/** User-creatable node types (derived from nodeDefinitions keys) */
+export type UserCreatableNodeType = keyof typeof nodeDefinitions;
+/** All node types including internal executor types */
+export type NodeType = UserCreatableNodeType | InternalNodeType;
+/** Extract config type from a node definition */
+type ConfigOf<T> = T extends {
+    defaults: infer D;
+} ? D : never;
+/** Union of all node config types */
+export type NodeConfig = ConfigOf<(typeof nodeDefinitions)[UserCreatableNodeType]>;
+/**
+ * Config type lookup by node ID.
+ * Use WorkflowConfig['node-id'] to get the config type for a specific node.
+ * @example WorkflowConfig['llm'] // LLM node config type
+ * @example WorkflowConfig['account'] // Account node config type
+ */
+export type WorkflowConfig = {
+    [K in UserCreatableNodeType]: ConfigOf<(typeof nodeDefinitions)[K]>;
+};
+export { internalNodeTypes, type InternalNodeType };
+export type { NodeDefinition } from './types';
+type AnyNodeDefinition = NodeDefinition<any, any, any>;
 /**
  * Get all node definitions as an array
  */
@@ -17,4 +310,3 @@ export declare function getAllNodeDefinitions(): AnyNodeDefinition[];
  * Get a node definition by its nodeId
  */
 export declare function getNodeDefinition(nodeId: UserCreatableNodeType): AnyNodeDefinition | undefined;
-export {};