ugcinc 4.0.2 → 4.1.0

package/dist/nodes/recurrence.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const definition = {
+    nodeId: 'recurrence',
+    label: 'Recurring',
+    description: 'Run continuously',
+    type: 'trigger',
+    category: 'Triggers',
+    getDefaultConfig: () => ({
+        recurrenceConfig: {
+            frequencyType: 'per-day',
+            runsPerDay: 1,
+            periodDays: 7,
+            daysOfWeek: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday'],
+            timingType: 'random-window',
+            specificTimes: ['09:00'],
+            randomWindowStart: '09:00',
+            randomWindowEnd: '17:00',
+            timezone: 'America/New_York',
+        },
+    }),
+    computePorts: ({ config }) => {
+        const recurrenceConfig = config?.recurrenceConfig;
+        const outputs = [];
+        // Add account output if collection input is enabled
+        if (recurrenceConfig?.collectionInput?.enabled) {
+            outputs.push({ id: 'account', type: 'account', isArray: false, required: true });
+        }
+        // Add media outputs
+        const mediaOutputs = recurrenceConfig?.mediaInput?.outputs ?? [];
+        for (const output of mediaOutputs) {
+            outputs.push({
+                id: output.id,
+                type: output.type,
+                isArray: false,
+                required: true,
+            });
+        }
+        return {
+            inputs: [],
+            outputs,
+        };
+    },
+};
+exports.default = definition;

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

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from '../types';
+declare const definition: NodeDefinition;
+export default definition;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const definition = {
+    nodeId: 'save-to-media',
+    label: 'Save To Media',
+    description: 'Save outputs to media library',
+    type: 'terminal',
+    category: 'Output',
+    getDefaultConfig: () => ({
+        saveToMediaConfig: {
+            inputs: [{ id: 'input', type: 'image' }],
+        },
+    }),
+    computePorts: ({ config }) => {
+        const saveConfig = config?.saveToMediaConfig;
+        const configInputs = saveConfig?.inputs ?? [];
+        const inputs = configInputs.map(input => ({
+            id: input.id,
+            type: input.type,
+            isArray: false,
+            required: true,
+        }));
+        return { inputs, outputs: [] };
+    },
+};
+exports.default = definition;

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

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

package/dist/nodes/screenshot-animation.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: 'screenshot-animation',
+    label: 'Animate Screenshot',
+    description: 'Create an iPhone screenshot animation from an image',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        holdDurationMs: 500,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'image',
+                type: 'image',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'output',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

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

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from '../types';
+declare const definition: NodeDefinition;
+export default definition;

package/dist/nodes/social-audio.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const definition = {
+    nodeId: 'social-audio',
+    label: 'Social Audio',
+    description: 'Select trending audio for posts',
+    type: 'source',
+    category: 'Sources',
+    getDefaultConfig: () => ({
+        urls: [],
+        selectedMediaIds: [],
+        selectionConfig: { mode: 'random' },
+    }),
+    computePorts: () => ({
+        inputs: [],
+        outputs: [
+            {
+                id: 'social-audio',
+                type: 'social_audio',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+};
+exports.default = definition;

package/dist/nodes/text.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from '../types';
+declare const definition: NodeDefinition;
+export default definition;

package/dist/nodes/text.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const internal_utils_1 = require("../internal-utils");
+const definition = {
+    nodeId: 'text',
+    label: 'Text',
+    description: 'Use text collections',
+    type: 'source',
+    category: 'Sources',
+    getDefaultConfig: () => ({
+        textOptions: [],
+        selectionConfig: { mode: 'random' },
+        outputMode: 'per-input',
+    }),
+    computePorts: ({ config }) => {
+        const textOptions = (config?.textOptions ?? []);
+        const variables = (0, internal_utils_1.extractTemplateVariables)(textOptions);
+        // Generate inputs from template variables
+        const inputs = variables.map(variable => ({
+            id: variable,
+            type: 'text',
+            isArray: false,
+            required: false,
+        }));
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'text',
+                    type: 'text',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+};
+exports.default = definition;

package/dist/nodes/transcript.d.ts

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from '../types';
+declare const definition: NodeDefinition;
+export default definition;

package/dist/nodes/transcript.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const definition = {
+    nodeId: 'transcript',
+    label: 'Transcribe',
+    description: 'Transcribe video or audio with timestamps',
+    type: 'generator',
+    category: 'Generation',
+    getDefaultConfig: () => ({
+        outputMode: 'per-input',
+    }),
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'media',
+                type: ['video', 'audio'],
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'text',
+                type: 'text',
+                isArray: false,
+                required: true,
+            },
+            {
+                id: 'segments',
+                type: 'object',
+                isArray: false,
+                required: true,
+                objectSchema: [
+                    { name: 'text', type: 'string' },
+                    { name: 'start', type: 'number' },
+                    { name: 'end', type: 'number' },
+                ],
+            },
+        ],
+    }),
+};
+exports.default = definition;

package/dist/nodes/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Node Definition Types
+ *
+ * This file contains shared types for node definitions.
+ * Each node file imports from here and defines its behavior.
+ */
+import type { NodePort, BasePortType } from '../types';
+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';
+type PrimitiveType = 'string' | 'number' | 'boolean';
+/**
+ * Generic type for object schema fields with compile-time depth enforcement.
+ *
+ * - Level 1 (default): Can have 'object' or 'array' types, arrays can contain objects
+ * - Level 2: Can have 'object' or 'array' types, arrays cannot contain objects
+ * - Level 3: Only primitive types allowed
+ *
+ * @example
+ * // Level 1 field (top-level)
+ * const field: SchemaField = { name: 'users', type: 'array', items: 'object', objectSchema: [...] };
+ *
+ * // Level 2 field (inside objectSchema)
+ * const nested: SchemaField<true, false> = { name: 'tags', type: 'array', items: 'string' };
+ *
+ * // Level 3 field (deepest level)
+ * const leaf: SchemaField<false, false> = { name: 'id', type: 'string' };
+ */
+/**
+ * Schema field type with compile-time depth enforcement for array items.
+ *
+ * - Level 1 (default): Arrays can contain objects (`items: 'object'`)
+ * - Level 2+: Arrays can only contain primitives
+ *
+ * The `objectSchema` property is always `ObjectSchemaField[]` so it can be
+ * passed directly to ports without type mismatches.
+ */
+export type SchemaField<CanNestObjects extends boolean = true> = {
+    name: string;
+    description?: string;
+    type: PrimitiveType | 'object' | 'array';
+    items?: PrimitiveType | (CanNestObjects extends true ? 'object' : never);
+    objectSchema?: ObjectSchemaField[];
+    length?: number;
+    minLength?: number;
+    maxLength?: number;
+    required?: boolean;
+};
+/** Top-level schema field - arrays can contain objects */
+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;
+    exhaustionBehavior?: ExhaustionBehavior;
+}
+export interface SelectionState {
+    usedIndices: number[];
+    currentIndex: number;
+}
+/**
+ * Computes the required outputMode/selectionMode types based on node category.
+ * - trigger/terminal: both null
+ * - generator: outputMode required, selectionMode null
+ * - source: both required
+ */
+type DefaultsForCategory<T extends NodeCategory, TCustom extends Record<string, unknown>> = T extends 'source' ? TCustom & {
+    outputMode: OutputMode;
+    selectionMode: SelectionMode;
+} : T extends 'generator' ? TCustom & {
+    outputMode: OutputMode;
+    selectionMode: null;
+} : TCustom & {
+    outputMode: null;
+    selectionMode: null;
+};
+/**
+ * Computes the outputModes array type based on node category.
+ */
+type OutputModesForCategory<T extends NodeCategory> = T extends 'source' | 'generator' ? OutputMode[] : null;
+/**
+ * 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>> {
+    nodeId: string;
+    label: string;
+    description: string;
+    type: T;
+    category: string;
+    outputModes: OutputModesForCategory<T>;
+    selectionModes: SelectionModesForCategory<T>;
+    defaults: DefaultsForCategory<T, TDefaults>;
+    computePorts: (params: {
+        config: DefaultsForCategory<T, TDefaults>;
+        getConnectedOutput?: (inputId: string) => {
+            type: BasePortType | BasePortType[];
+            isArray: boolean;
+            objectSchema?: ObjectSchemaField[];
+        } | null;
+    }) => {
+        inputs: NodePort[];
+        outputs: NodePort[];
+    };
+}
+/**
+ * Define a node with full type inference.
+ *
+ * - outputMode/selectionMode in defaults are typed based on the node's `type`
+ * - 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: {
+    nodeId: string;
+    label: string;
+    description: string;
+    type: T;
+    category: string;
+    outputModes: OutputModesForCategory<T>;
+    selectionModes: SelectionModesForCategory<T>;
+    defaults: DefaultsForCategory<T, TCustomDefaults>;
+    computePorts: (params: {
+        config: DefaultsForCategory<T, TCustomDefaults>;
+        getConnectedOutput?: (inputId: string) => {
+            type: BasePortType | BasePortType[];
+            isArray: boolean;
+            objectSchema?: ObjectSchemaField[];
+        } | null;
+    }) => {
+        inputs: NodePort[];
+        outputs: NodePort[];
+    };
+}): NodeDefinition<T, TCustomDefaults>;
+export {};

package/dist/nodes/types.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Node Definition Types
+ *
+ * This file contains shared types for node definitions.
+ * Each node file imports from here and defines its behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineNode = defineNode;
+// =============================================================================
+// Helper Function
+// =============================================================================
+/**
+ * Define a node with full type inference.
+ *
+ * - outputMode/selectionMode in defaults are typed based on the node's `type`
+ * - Custom defaults are merged and available in computePorts
+ * - No manual type assertions needed
+ */
+function defineNode(def) {
+    return def;
+}

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

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from '../types';
+declare const definition: NodeDefinition;
+export default definition;

package/dist/nodes/video-composer.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const definition = {
+    nodeId: 'video-composer',
+    label: 'Video Composer',
+    description: 'Create templated videos',
+    type: 'generator',
+    category: 'Generation',
+    getDefaultConfig: () => ({
+        videoEditor: {
+            width: 1080,
+            height: 1920,
+            fps: 30,
+            dimensionPreset: '9:16',
+            channels: [{
+                    id: 'main-track',
+                    name: 'Main Track',
+                    segments: [],
+                }],
+        },
+        outputMode: 'per-input',
+    }),
+    computePorts: ({ config }) => {
+        const editorConfig = config?.videoEditor;
+        const inputs = [];
+        const addedIds = new Set();
+        if (editorConfig) {
+            editorConfig.channels.forEach(channel => {
+                channel.segments.forEach(segment => {
+                    if (segment.inputRef && !addedIds.has(segment.inputRef)) {
+                        addedIds.add(segment.inputRef);
+                        const inputType = segment.type === 'video' ? 'video'
+                            : segment.type === 'audio' ? 'audio'
+                                : 'image';
+                        inputs.push({
+                            id: segment.inputRef,
+                            type: inputType,
+                            isArray: false,
+                            required: segment.required ?? true,
+                        });
+                    }
+                    if (segment.textInputRef && !addedIds.has(segment.textInputRef)) {
+                        addedIds.add(segment.textInputRef);
+                        inputs.push({
+                            id: segment.textInputRef,
+                            type: 'text',
+                            isArray: false,
+                            required: segment.required ?? true,
+                        });
+                    }
+                });
+            });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'video',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+};
+exports.default = definition;

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

@@ -0,0 +1,3 @@
+import type { NodeDefinition } from '../types';
+declare const definition: NodeDefinition;
+export default definition;

package/dist/nodes/video-import.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const definition = {
+    nodeId: 'video-import',
+    label: 'Import Video',
+    description: 'Import videos from YouTube, TikTok, Instagram & more',
+    type: 'source',
+    category: 'Sources',
+    getDefaultConfig: () => ({
+        videoImportConfig: {
+            platform: 'youtube',
+            videoQuality: '1080',
+        },
+        outputMode: 'per-input',
+    }),
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'url',
+                type: 'text',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'video',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+};
+exports.default = definition;

package/dist/org.d.ts

@@ -1,5 +1,17 @@
 import { BaseClient } from './base';
-import type { ApiKey, ApiResponse, DeleteApiKeyParams, EditApiKeyParams } from './types';
+import type { ApiResponse } from './types';
+export interface ApiKey {
+    id: string;
+    name: string;
+    created_at: string;
+}
+export interface DeleteApiKeyParams {
+    apiKeyId: string;
+}
+export interface EditApiKeyParams {
+    apiKeyId: string;
+    name: string;
+}
 /**
  * Client for managing organization resources
  */

package/dist/ports.js

@@ -33,7 +33,7 @@ function extractTemplateVariables(texts) {
  */
 function computeInputPorts({ node }) {
     const nodeConfigs = (0, automations_1.getAllNodes)();
-    const nodeConfig = nodeConfigs.find(n => n.type === node.type);
+    const nodeConfig = nodeConfigs.find(n => n.nodeId === node.type);
     const baseInputs = nodeConfig?.inputs ?? [];
     // Text nodes: generate inputs from template variables
     if (node.type === 'text') {
@@ -135,13 +135,7 @@ function computeInputPorts({ node }) {
         const variableNodes = node.config?.workflowVariableNodes;
         if (!variableNodes || variableNodes.length === 0)
             return baseInputs;
-        const passThrough = (node.config?.workflowPassThrough ?? {});
-        return variableNodes
-            .filter(v => {
-            const varName = v.name ?? v.id;
-            return !passThrough[varName];
-        })
-            .map(v => {
+        return variableNodes.map(v => {
             const varType = v.variableType === 'dropdown' ? 'text' : (v.variableType ?? 'text');
             return {
                 id: v.id,
@@ -320,7 +314,7 @@ function computeOutputPorts({ node }) {
     }
     // Fallback: use static outputs from getAllNodes() for nodes without dynamic ports
     const nodeConfigs = (0, automations_1.getAllNodes)();
-    const nodeConfig = nodeConfigs.find(n => n.type === node.type);
+    const nodeConfig = nodeConfigs.find(n => n.nodeId === node.type);
     return nodeConfig?.outputs ?? [];
 }
 /**

package/dist/posts.d.ts

@@ -1,5 +1,92 @@
 import { BaseClient } from './base';
-import type { Post, GetPostsParams, CreateSlideshowParams, GetPostStatusParams, CreateVideoParams, DeletePostsParams, DeletePostsResponse, RetryPostsParams, ApiResponse } from './types';
+import type { ApiResponse } from './types';
+export type PostType = 'video' | 'slideshow';
+export type PostStatus = 'scheduled' | 'pending' | 'complete' | 'failed' | 'retrying' | 'deleting' | 'deleted' | 'hidden' | 'require-approval';
+export interface Post {
+    id: string;
+    account_id: string;
+    type: PostType;
+    status: PostStatus;
+    social_id: string | null;
+    caption: string | null;
+    title: string | null;
+    media_urls: string[] | null;
+    music_post_id: string | null;
+    social_audio_id: string | null;
+    scheduled_at: string | null;
+    postUrl?: string;
+}
+export interface PostStat {
+    id: string;
+    post_id: string;
+    views: number | null;
+    likes: number | null;
+    comments: number | null;
+    shares: number | null;
+    saves: number | null;
+    created_at: string;
+}
+export interface GetPostsParams {
+    accountIds?: string[];
+    postIds?: string[];
+    startDate?: string;
+    endDate?: string;
+}
+export interface CreateSlideshowParams {
+    accountId: string | null;
+    caption?: string;
+    title?: string;
+    socialAudioId?: string;
+    postTime?: string;
+    imageUrls: string[];
+    strict?: boolean;
+    tag?: string;
+    user_group?: string;
+    org_group?: string;
+}
+export interface GetPostStatsParams {
+    postIds?: string[];
+    startDate?: string;
+    endDate?: string;
+}
+export interface GetPostStatusParams {
+    postId: string;
+}
+export interface CreateVideoParams {
+    accountId: string | null;
+    caption?: string;
+    socialAudioId?: string;
+    postTime?: string;
+    videoUrl: string;
+    strict?: boolean;
+    tag?: string;
+    user_group?: string;
+    org_group?: string;
+}
+export interface DeletePostsParams {
+    postIds: string[];
+}
+export interface DeletePostsResponse {
+    deleted: number;
+    deleting: number;
+    deletedIds: string[];
+    deletingIds: string[];
+    errors?: Array<{
+        postId: string;
+        error: string;
+    }>;
+}
+export interface RetryPostsParams {
+    postIds: string[];
+}
+export interface SetPostStatusParams {
+    postIds: string[];
+    status: string;
+}
+export interface SetPostStatusResponse {
+    updated: number;
+    ids: string[];
+}
 /**
  * Client for managing posts
  */