ugcinc 4.0.2 → 4.1.0

package/dist/nodes/create-dm.d.ts

@@ -0,0 +1,40 @@
+import type { InputType } from './types';
+type DmPlatform = 'imessage' | 'instagram';
+interface DmMessage {
+    sender: 'user' | 'recipient';
+    text: string;
+    hasImage?: boolean;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    platform: DmPlatform;
+    platformIsVariable: boolean;
+    lightMode: boolean;
+    lightModeIsVariable: boolean;
+    username: string;
+    usernameIsVariable: boolean;
+    time: string;
+    timeIsVariable: boolean;
+    profilePicUrl: string;
+    profilePicIsVariable: boolean;
+    messagesInputType: InputType;
+    messages: DmMessage[];
+    imageAttachmentUrl: string | undefined;
+    imageAttachmentIsVariable: boolean;
+    imessage: {
+        senderBubbleColor: string | undefined;
+        showReadReceipt: boolean;
+        readReceiptText: string;
+        readReceiptTimeIsVariable: boolean;
+        unreadBadgeText: string;
+        unreadBadgeIsVariable: boolean;
+        messageHeaderTimestampText: string;
+        messageHeaderTimeIsVariable: boolean;
+    };
+    instagram: {
+        userHasStory: boolean;
+    };
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type CreateDmConfig = typeof definition.defaults;

package/dist/nodes/create-dm.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'create-dm',
+    label: 'Create DM',
+    description: 'Create fake DM screenshots for iMessage or Instagram',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        platform: 'instagram',
+        platformIsVariable: false,
+        lightMode: true,
+        lightModeIsVariable: false,
+        username: '',
+        usernameIsVariable: false,
+        time: '9:41',
+        timeIsVariable: false,
+        profilePicUrl: 'https://ugcinc.co/logo.png',
+        profilePicIsVariable: false,
+        messagesInputType: '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 😭😭😭' },
+        ],
+        imageAttachmentUrl: undefined,
+        imageAttachmentIsVariable: false,
+        imessage: {
+            senderBubbleColor: undefined,
+            showReadReceipt: false,
+            readReceiptText: 'Read',
+            readReceiptTimeIsVariable: false,
+            unreadBadgeText: '67',
+            unreadBadgeIsVariable: false,
+            messageHeaderTimestampText: '',
+            messageHeaderTimeIsVariable: false,
+        },
+        instagram: {
+            userHasStory: false,
+        },
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const inputs = [];
+        if (config?.platformIsVariable) {
+            inputs.push({ id: 'platform', type: 'text', isArray: false, required: true });
+        }
+        if (config?.lightModeIsVariable) {
+            inputs.push({ id: 'light-mode', type: 'boolean', isArray: false, required: false });
+        }
+        if (config?.usernameIsVariable) {
+            inputs.push({ id: 'username', type: 'text', isArray: false, required: true });
+        }
+        if (config?.timeIsVariable) {
+            inputs.push({ id: 'time', type: 'text', isArray: false, required: false });
+        }
+        if (config?.profilePicIsVariable) {
+            inputs.push({ id: 'profile-pic', type: 'image', isArray: false, required: false });
+        }
+        if (config?.messagesInputType === 'variable') {
+            inputs.push({ id: 'messages', type: 'object', isArray: true, required: true });
+        }
+        if (config?.imageAttachmentIsVariable) {
+            inputs.push({ id: 'image-attachment', type: 'image', isArray: false, required: false });
+        }
+        // iMessage-specific
+        if (config?.platform === 'imessage') {
+            if (config.imessage?.showReadReceipt && config.imessage?.readReceiptTimeIsVariable) {
+                inputs.push({ id: 'read-receipt-time', type: 'text', isArray: false, required: false });
+            }
+            if (config.imessage?.unreadBadgeIsVariable) {
+                inputs.push({ id: 'unread-badge', type: 'text', isArray: false, required: false });
+            }
+            if (config.imessage?.messageHeaderTimeIsVariable) {
+                inputs.push({ id: 'message-header-time', type: 'text', isArray: false, required: false });
+            }
+        }
+        return {
+            inputs,
+            outputs: [{ id: 'output', type: 'image', isArray: false, required: true }],
+        };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,19 @@
+type CustomModelOutputType = 'image' | 'video' | 'audio';
+interface CustomModelInputParam {
+    name: string;
+    type: string;
+    required: boolean;
+    description?: string;
+    default?: unknown;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    modelId: string;
+    modelName: string;
+    outputType: CustomModelOutputType;
+    inputParams: CustomModelInputParam[];
+    apiKey: string | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type CustomModelConfig = typeof definition.defaults;

package/dist/nodes/custom-model.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'custom-model',
+    label: 'Custom Model',
+    description: 'Call any fal.ai model',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        modelId: '',
+        modelName: '',
+        outputType: 'image',
+        inputParams: [],
+        apiKey: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const inputParams = config?.inputParams ?? [];
+        const outputType = config?.outputType ?? 'image';
+        // Generate input ports from inputParams
+        // Only params with name 'prompt' or type image/video/audio become input ports
+        const inputs = inputParams
+            .filter(param => param.name === 'prompt' ||
+            param.type === 'image' ||
+            param.type === 'video' ||
+            param.type === 'audio')
+            .map(param => ({
+            id: param.name,
+            type: (param.type === 'image' || param.type === 'video' || param.type === 'audio')
+                ? param.type
+                : 'text',
+            isArray: false,
+            required: param.required,
+        }));
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: outputType,
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

package/dist/nodes/deduplicate.d.ts

@@ -0,0 +1,8 @@
+import type { DeduplicationLevel } from '../render/types';
+declare const definition: import("./types").NodeDefinition<"generator", {
+    deduplication: DeduplicationLevel;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type DeduplicateConfig = typeof definition.defaults;

package/dist/nodes/deduplicate.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'deduplicate',
+    label: 'Mass Repost',
+    description: 'Make videos unique for safe reposting',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        deduplication: 'level3',
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'video',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'output',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

package/dist/nodes/destructure.d.ts

@@ -0,0 +1,25 @@
+type IndexExpression = {
+    type: 'single';
+    index: number;
+} | {
+    type: 'range';
+    start: number;
+    end: number;
+} | {
+    type: 'list';
+    indexes: number[];
+};
+interface DestructureSelection {
+    portId: string;
+    indexExpr: IndexExpression;
+    isVariable?: boolean;
+    propertyPath?: string;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    selections: DestructureSelection[];
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type { DestructureSelection, IndexExpression };
+export type DestructureConfig = typeof definition.defaults;

package/dist/nodes/destructure.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'destructure',
+    label: 'Destructure',
+    description: 'Extract specific elements from an array by index or range',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        selections: [],
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config, getConnectedOutput }) => {
+        const selections = config?.selections ?? [];
+        // Input accepts any array type
+        const inputTypes = ['image', 'video', 'audio', 'text', 'object'];
+        const inputs = [
+            {
+                id: 'array',
+                type: inputTypes,
+                isArray: true,
+                required: true,
+            },
+        ];
+        const outputs = [];
+        // Determine base type from connected input
+        let baseType = 'object';
+        if (getConnectedOutput) {
+            const connectedOutput = getConnectedOutput('array');
+            if (connectedOutput?.type && connectedOutput.isArray) {
+                const connType = connectedOutput.type;
+                if (!Array.isArray(connType)) {
+                    baseType = connType;
+                }
+            }
+        }
+        for (const selection of selections) {
+            // If variable, add input port for index expression
+            if (selection.isVariable) {
+                inputs.push({
+                    id: `idx-${selection.portId}`,
+                    type: 'text',
+                    isArray: false,
+                    required: true,
+                });
+            }
+            // Output type depends on index expression:
+            // - 'single' -> single item (isArray: false)
+            // - 'range' or 'list' -> array of items (isArray: true)
+            const outputIsArray = selection.indexExpr.type !== 'single';
+            outputs.push({
+                id: selection.portId,
+                type: baseType,
+                isArray: outputIsArray,
+                required: true,
+            });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,23 @@
+import type { BasePortType } from '../types';
+interface ForEachOutputProperty {
+    portId: string;
+    propertyPath: string;
+    type: BasePortType;
+    isArray: boolean;
+}
+interface ForEachInputPort {
+    id: string;
+    type: BasePortType;
+    isArray: boolean;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    outputProperties: ForEachOutputProperty[];
+    inputPorts: ForEachInputPort[];
+    exposeItem: boolean;
+    exposeIndex: boolean;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type { ForEachOutputProperty, ForEachInputPort };
+export type ForEachConfig = typeof definition.defaults;

package/dist/nodes/for-each.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'for-each',
+    label: 'For Each',
+    description: 'Iterate over an array, executing downstream nodes for each item',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        outputProperties: [],
+        inputPorts: [],
+        exposeItem: false,
+        exposeIndex: false,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config, getConnectedOutput }) => {
+        const outputProperties = config?.outputProperties ?? [];
+        const inputPorts = config?.inputPorts ?? [];
+        const exposeItem = config?.exposeItem ?? false;
+        const exposeIndex = config?.exposeIndex ?? false;
+        // Inputs: array + passthrough inputs
+        const inputs = [
+            { id: 'array', type: 'object', isArray: false, required: true },
+        ];
+        for (const port of inputPorts) {
+            inputs.push({
+                id: port.id,
+                type: port.type,
+                isArray: port.isArray,
+                required: false,
+            });
+        }
+        // Outputs
+        const outputs = [];
+        // Determine item type from connected array input
+        let itemType = 'object';
+        if (getConnectedOutput) {
+            const connectedOutput = getConnectedOutput('array');
+            if (connectedOutput?.objectSchema) {
+                // Has objectSchema - it's an object array, use object type
+                itemType = 'object';
+            }
+            else if (connectedOutput?.type && connectedOutput.isArray) {
+                // Connected to an array type - extract the base type
+                const connType = connectedOutput.type;
+                if (!Array.isArray(connType)) {
+                    itemType = connType;
+                }
+            }
+        }
+        // Add item output if exposed
+        if (exposeItem) {
+            outputs.push({ id: 'item', type: itemType, isArray: false, required: true });
+        }
+        // Add index output if exposed
+        if (exposeIndex) {
+            outputs.push({ id: 'index', type: 'number', isArray: false, required: true });
+        }
+        // Add configured property outputs
+        for (const prop of outputProperties) {
+            outputs.push({
+                id: prop.portId,
+                type: prop.type,
+                isArray: prop.isArray,
+                required: true,
+            });
+        }
+        // Add passthrough outputs (same value for all iterations)
+        for (const port of inputPorts) {
+            outputs.push({
+                id: port.id,
+                type: port.type,
+                isArray: port.isArray,
+                required: true,
+            });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,16 @@
+type ImageGenerationTextModel = 'fal-ai/gemini-3-pro-image-preview' | 'fal-ai/nano-banana-pro' | 'fal-ai/nano-banana' | 'fal-ai/gpt-image-1/text-to-image';
+type ImageGenerationEditModel = 'fal-ai/gemini-3-pro-image-preview/edit' | 'fal-ai/nano-banana-pro/edit' | 'fal-ai/nano-banana/edit' | 'fal-ai/gpt-image-1/edit-image';
+type ImageGenerationModel = ImageGenerationTextModel | ImageGenerationEditModel;
+declare function isEditModel(model: ImageGenerationModel): model is ImageGenerationEditModel;
+declare const definition: import("./types").NodeDefinition<"generator", {
+    model: ImageGenerationModel;
+    aspectRatio: string;
+    numImages: number;
+    apiKey: string | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export { isEditModel };
+export type { ImageGenerationTextModel, ImageGenerationEditModel, ImageGenerationModel };
+export type GenerateImageConfig = typeof definition.defaults;

package/dist/nodes/generate-image.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEditModel = isEditModel;
+const types_1 = require("./types");
+function isEditModel(model) {
+    return model.includes('/edit') || model.includes('/edit-image');
+}
+const definition = (0, types_1.defineNode)({
+    nodeId: 'generate-image',
+    label: 'Generate Image',
+    description: 'Generate images with AI',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        model: 'fal-ai/nano-banana',
+        aspectRatio: '1:1',
+        numImages: 1,
+        apiKey: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const model = (config?.model ?? 'fal-ai/nano-banana');
+        const inputs = [
+            { id: 'prompt', type: 'text', isArray: false, required: true },
+        ];
+        if (isEditModel(model)) {
+            inputs.push({ id: 'image', type: 'image', isArray: false, required: true });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'image',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,16 @@
+type VideoGenerationTextToVideoModel = 'fal-ai/veo3.1' | 'fal-ai/veo3' | 'fal-ai/veo3/fast' | 'fal-ai/kling-video/v2.6/pro/text-to-video' | 'fal-ai/kling-video/v2.5/pro/text-to-video' | 'fal-ai/luma-dream-machine/ray-2' | 'fal-ai/luma-dream-machine/ray-2-flash' | 'fal-ai/minimax/hailuo-2.3/pro/text-to-video' | 'wan/v2.6/text-to-video' | 'fal-ai/sora-2/text-to-video';
+type VideoGenerationImageToVideoModel = 'fal-ai/veo3.1/image-to-video' | 'fal-ai/veo3/image-to-video' | 'fal-ai/kling-video/v2.6/pro/image-to-video' | 'fal-ai/kling-video/v2.5/pro/image-to-video' | 'fal-ai/luma-dream-machine/ray-2/image-to-video' | 'fal-ai/luma-dream-machine/ray-2-flash/image-to-video' | 'fal-ai/minimax/hailuo-2.3/pro/image-to-video' | 'wan/v2.6/image-to-video' | 'fal-ai/sora-2/image-to-video/pro';
+type VideoGenerationModel = VideoGenerationTextToVideoModel | VideoGenerationImageToVideoModel;
+declare function isImageToVideoModel(model: VideoGenerationModel): model is VideoGenerationImageToVideoModel;
+declare const definition: import("./types").NodeDefinition<"generator", {
+    model: VideoGenerationModel;
+    aspectRatio: string;
+    duration: number;
+    apiKey: string | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export { isImageToVideoModel };
+export type { VideoGenerationTextToVideoModel, VideoGenerationImageToVideoModel, VideoGenerationModel };
+export type GenerateVideoConfig = typeof definition.defaults;

package/dist/nodes/generate-video.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageToVideoModel = isImageToVideoModel;
+const types_1 = require("./types");
+function isImageToVideoModel(model) {
+    return model.includes('/image-to-video');
+}
+const definition = (0, types_1.defineNode)({
+    nodeId: 'generate-video',
+    label: 'Generate Video',
+    description: 'Generate videos with AI',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        model: 'fal-ai/kling-video/v2.6/pro/text-to-video',
+        aspectRatio: '16:9',
+        duration: 5,
+        apiKey: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const model = (config?.model ?? 'fal-ai/kling-video/v2.6/pro/text-to-video');
+        const inputs = [
+            { id: 'prompt', type: 'text', isArray: false, required: true },
+        ];
+        if (isImageToVideoModel(model)) {
+            inputs.push({ id: 'image', type: 'image', isArray: false, required: true });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'video',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

package/dist/nodes/if.d.ts

@@ -0,0 +1,22 @@
+import type { BasePortType } from '../types';
+declare const IfLogicOperators: readonly ["and", "or", "xor", "nor"];
+type IfLogicOperator = typeof IfLogicOperators[number];
+interface IfBooleanInput {
+    id: string;
+}
+interface IfPassthroughInput {
+    id: string;
+    type: BasePortType;
+    isArray: boolean;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    logicOperator: IfLogicOperator;
+    booleanInputs: IfBooleanInput[];
+    passthroughInputs: IfPassthroughInput[];
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export { IfLogicOperators };
+export type { IfLogicOperator, IfBooleanInput, IfPassthroughInput };
+export type IfConfig = typeof definition.defaults;

package/dist/nodes/if.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IfLogicOperators = void 0;
+const types_1 = require("./types");
+const IfLogicOperators = ['and', 'or', 'xor', 'nor'];
+exports.IfLogicOperators = IfLogicOperators;
+const definition = (0, types_1.defineNode)({
+    nodeId: 'if',
+    label: 'If',
+    description: 'Conditional branching based on boolean logic',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        logicOperator: 'and',
+        booleanInputs: [{ id: 'condition-1' }],
+        passthroughInputs: [{
+                id: 'value',
+                type: 'image',
+                isArray: false,
+            }],
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const booleanInputs = config?.booleanInputs ?? [];
+        const passthroughInputs = config?.passthroughInputs ?? [];
+        const inputs = [];
+        const outputs = [];
+        // Boolean condition inputs
+        for (const boolInput of booleanInputs) {
+            inputs.push({ id: boolInput.id, type: 'boolean', isArray: false, required: true });
+        }
+        // Passthrough inputs and true/false outputs
+        for (const passthrough of passthroughInputs) {
+            inputs.push({ id: passthrough.id, type: passthrough.type, isArray: passthrough.isArray, required: true });
+            outputs.push({ id: `true-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true });
+            outputs.push({ id: `false-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,14 @@
+declare const definition: import("./types").NodeDefinition<"generator", {
+    imageEditor: {
+        width: number;
+        height: number;
+        aspectRatio: string;
+        dimensionPreset: string;
+        backgroundType: string;
+        elements: never[];
+    };
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type ImageComposerConfig = typeof definition.defaults;