ugcinc 4.1.21 → 4.1.23

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

@@ -1,21 +1,24 @@
-import { type InputType } from './types';
+import { type ObjectSchemaField } from './types';
 export interface BranchDefinition {
     key: string;
 }
 export interface BranchValueConfig {
-    inputType?: InputType;
+    isVariable?: boolean;
     value?: unknown;
     selectedMediaIds?: string[];
 }
-export interface PassthroughInput {
+export interface BranchPassthroughInput {
     id: string;
     type: string;
     isArray?: boolean;
     branchValues?: Record<string, BranchValueConfig>;
+    objectSchema?: ObjectSchemaField[];
 }
+/** @deprecated Use BranchPassthroughInput instead */
+export type PassthroughInput = BranchPassthroughInput;
 declare const definition: import("./types").NodeDefinition<"generator", {
     branches: BranchDefinition[];
-    passthroughInputs: PassthroughInput[];
+    passthroughInputs: BranchPassthroughInput[];
     defaultBranchKey: string;
     outputMode: "per-input";
     selectionMode: null;

package/dist/automations/nodes/branch.js

@@ -19,7 +19,7 @@ const definition = (0, types_1.defineNode)({
         outputMode: 'per-input',
         selectionMode: null,
     },
-    computePorts: ({ config }) => {
+    computePorts: ({ config, getConnectedOutput }) => {
         const branches = config?.branches ?? [];
         const passthroughInputs = config?.passthroughInputs ?? [];
         const inputs = [];
@@ -28,18 +28,39 @@ const definition = (0, types_1.defineNode)({
         for (const passthrough of passthroughInputs) {
             const pType = passthrough.type;
             const pIsArray = passthrough.isArray ?? false;
+            // Track input port IDs for this passthrough to check for connected schemas
+            const variableInputPortIds = [];
             for (const branch of branches) {
                 const branchValue = passthrough.branchValues?.[branch.key];
-                if (branchValue?.inputType === 'variable') {
+                if (branchValue?.isVariable) {
+                    const inputPortId = `${branch.key}-${passthrough.id}`;
+                    variableInputPortIds.push(inputPortId);
                     inputs.push({
-                        id: `${branch.key}-${passthrough.id}`,
+                        id: inputPortId,
                         type: pType,
                         isArray: pIsArray,
                         required: true,
                     });
                 }
             }
-            outputs.push({ id: passthrough.id, type: pType, isArray: pIsArray, required: true });
+            // Get objectSchema from connected input (if any) to propagate to output
+            let objectSchema = passthrough.objectSchema;
+            if (getConnectedOutput && !objectSchema) {
+                for (const inputPortId of variableInputPortIds) {
+                    const connectedOutput = getConnectedOutput(inputPortId);
+                    if (connectedOutput?.objectSchema) {
+                        objectSchema = connectedOutput.objectSchema;
+                        break; // Use the first connected schema found
+                    }
+                }
+            }
+            outputs.push({
+                id: passthrough.id,
+                type: pType,
+                isArray: pIsArray,
+                required: true,
+                objectSchema,
+            });
         }
         return { inputs, outputs };
     },

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

@@ -49,7 +49,7 @@ export declare const nodeDefinitions: {
     }, false>;
     readonly branch: NodeDefinition<"generator", {
         branches: import("./branch").BranchDefinition[];
-        passthroughInputs: import("./branch").PassthroughInput[];
+        passthroughInputs: import("./branch").BranchPassthroughInput[];
         defaultBranchKey: string;
         outputMode: "per-input";
         selectionMode: null;

package/dist/index.d.ts

@@ -36,7 +36,7 @@ export { prepareImageComposerInput } from './automations/nodes/image-composer';
 export type { AccountNodeConfig } from './automations/nodes/account';
 export type { AutoCaptionNodeConfig, AutoCaptionPreset, AutoCaptionFontWeight, AutoCaptionPosition, } from './automations/nodes/auto-caption';
 export type { AutoPostNodeConfig, AutoPostMode, PostSchedulingMode, } from './automations/nodes/auto-post';
-export type { BranchNodeConfig, BranchDefinition, PassthroughInput, } from './automations/nodes/branch';
+export type { BranchNodeConfig, BranchDefinition, BranchPassthroughInput, BranchValueConfig, PassthroughInput, } from './automations/nodes/branch';
 export type { CollectNodeConfig } from './automations/nodes/collect';
 export type { ComposeWorkflowNodeConfig } from './automations/nodes/compose-workflow';
 export type { CreateDmNodeConfig, CreateDmMessage, DmPlatform, } from './automations/nodes/create-dm';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ugcinc",
-  "version": "4.1.21",
+  "version": "4.1.23",
   "description": "TypeScript/JavaScript client for the UGC Inc API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/automations.d.ts

@@ -1,173 +0,0 @@
-/**
- * Automations API Client
- *
- * Provides methods to interact with the UGC Inc Automations API.
- * For graph logic (validation, port computation, connections), use graph-controller.ts
- */
-import type { WorkflowDefinition, AutomationTemplate, AutomationRun, ExecutorNode, ExecutionEdge, ApiResponse, AutomationExport, AutomationRunExport } from './types';
-import { BaseClient } from './base';
-export declare class AutomationsClient extends BaseClient {
-    /**
-     * List all automation templates for an organization
-     */
-    listTemplates(params: {
-        orgId: string;
-    }): Promise<ApiResponse<AutomationTemplate[]>>;
-    /**
-     * Get a specific automation template
-     */
-    getTemplate(params: {
-        templateId: string;
-    }): Promise<ApiResponse<AutomationTemplate>>;
-    /**
-     * Create or update an automation template
-     * @param templateId - If provided, updates existing template instead of creating new one
-     * @param skipValidation - If true, skips workflow validation (for saving drafts)
-     */
-    createTemplate(params: {
-        orgId: string;
-        name: string;
-        description?: string;
-        workflowDefinition: WorkflowDefinition;
-        templateId?: string;
-        skipValidation?: boolean;
-    }): Promise<ApiResponse<string>>;
-    /**
-     * Delete an automation template
-     */
-    deleteTemplate(params: {
-        templateId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Run an automation template
-     * @param variableInputs - Optional map of variable node IDs to their runtime values
-     * @param saveAsPreview - If true, saves the output as a preview for sub-workflows
-     * @param tag - Optional tag for organizing runs
-     */
-    run(params: {
-        templateId: string;
-        orgId: string;
-        variableInputs?: Record<string, string>;
-        saveAsPreview?: boolean;
-        tag?: string;
-    }): Promise<ApiResponse<{
-        runId: string;
-    }>>;
-    /**
-     * Get automation run status
-     * Returns executors (expanded nodes) and edges (data flow connections)
-     */
-    getStatus(params: {
-        runId: string;
-    }): Promise<ApiResponse<{
-        run: AutomationRun;
-        executors: ExecutorNode[];
-        edges: ExecutionEdge[];
-    }>>;
-    /**
-     * List automation runs for a template
-     */
-    listRuns(params: {
-        templateId: string;
-        limit?: number;
-    }): Promise<ApiResponse<Array<{
-        run: AutomationRun;
-        nodeCount: number;
-    }>>>;
-    /**
-     * List all automation runs for the organization (across all templates)
-     * @param templateId - Optional filter to show runs from a specific automation only
-     */
-    listAllRuns(params: {
-        limit?: number;
-        reviewStatus?: 'pending_review' | 'approved' | 'rejected' | 'all';
-        templateId?: string;
-    }): Promise<ApiResponse<Array<{
-        run: AutomationRun;
-        templateName: string;
-        nodeCount: number;
-        completedNodeCount: number;
-    }>>>;
-    /**
-     * Update review status for a run
-     */
-    updateReviewStatus(params: {
-        runId: string;
-        reviewStatus: 'approved' | 'rejected';
-    }): Promise<ApiResponse<{
-        success: boolean;
-    }>>;
-    /**
-     * Validate a workflow definition without creating it
-     */
-    validateWorkflow(params: {
-        workflowDefinition: WorkflowDefinition;
-    }): Promise<ApiResponse<{
-        valid: boolean;
-        errors: string[];
-    }>>;
-    /**
-     * Delete an automation run
-     */
-    deleteRun(params: {
-        runId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Export automation template for debugging
-     * Returns the complete template definition with nodes and connections
-     */
-    exportTemplate(params: {
-        templateId: string;
-    }): Promise<ApiResponse<AutomationExport>>;
-    /**
-     * Export automation run for debugging
-     * Returns the complete run data including execution state, executor outputs, and edge values
-     */
-    exportRun(params: {
-        runId: string;
-    }): Promise<ApiResponse<AutomationRunExport>>;
-    /**
-     * Stop a running automation
-     * Marks the run as failed and all pending executors as failed.
-     * In-flight executors will complete gracefully.
-     */
-    stop(params: {
-        runId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Get the recurrence status for an automation template
-     * Returns whether the template has a recurrence node, if it's published, and schedule info
-     */
-    getRecurrenceStatus(params: {
-        templateId: string;
-    }): Promise<ApiResponse<{
-        hasRecurrence: boolean;
-        isPublished: boolean;
-        nextRunAt: string | null;
-        lastRunAt: string | null;
-    }>>;
-    /**
-     * Publish an automation - enables recurrence scheduling
-     * The automation will run automatically based on its recurrence configuration
-     */
-    publish(params: {
-        templateId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Unpublish an automation - disables recurrence and stops the scheduler workflow
-     * No more scheduled runs will occur until the automation is published again
-     */
-    unpublish(params: {
-        templateId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Run an automation once immediately
-     * If the automation is published, this also updates the schedule (restarts the scheduler)
-     * This is used for the "Run Once" button on recurrence automations
-     */
-    runOnce(params: {
-        templateId: string;
-    }): Promise<ApiResponse<{
-        runIds: string[];
-    }>>;
-}

package/dist/automations.js

@@ -1,194 +0,0 @@
-"use strict";
-/**
- * Automations API Client
- *
- * Provides methods to interact with the UGC Inc Automations API.
- * For graph logic (validation, port computation, connections), use graph-controller.ts
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutomationsClient = void 0;
-const base_1 = require("./base");
-class AutomationsClient extends base_1.BaseClient {
-    /**
-     * List all automation templates for an organization
-     */
-    async listTemplates(params) {
-        return this.request('/automations/list', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Get a specific automation template
-     */
-    async getTemplate(params) {
-        return this.request('/automations/get', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Create or update an automation template
-     * @param templateId - If provided, updates existing template instead of creating new one
-     * @param skipValidation - If true, skips workflow validation (for saving drafts)
-     */
-    async createTemplate(params) {
-        return this.request('/automations/create', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Delete an automation template
-     */
-    async deleteTemplate(params) {
-        return this.request('/automations/delete', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Run an automation template
-     * @param variableInputs - Optional map of variable node IDs to their runtime values
-     * @param saveAsPreview - If true, saves the output as a preview for sub-workflows
-     * @param tag - Optional tag for organizing runs
-     */
-    async run(params) {
-        return this.request('/automations/run', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Get automation run status
-     * Returns executors (expanded nodes) and edges (data flow connections)
-     */
-    async getStatus(params) {
-        return this.request('/automations/status', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * List automation runs for a template
-     */
-    async listRuns(params) {
-        return this.request('/automations/list-runs', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * List all automation runs for the organization (across all templates)
-     * @param templateId - Optional filter to show runs from a specific automation only
-     */
-    async listAllRuns(params) {
-        return this.request('/automations/list-all-runs', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Update review status for a run
-     */
-    async updateReviewStatus(params) {
-        return this.request('/automations/update-review-status', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Validate a workflow definition without creating it
-     */
-    async validateWorkflow(params) {
-        return this.request('/automations/validate', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Delete an automation run
-     */
-    async deleteRun(params) {
-        return this.request('/automations/delete-run', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Export automation template for debugging
-     * Returns the complete template definition with nodes and connections
-     */
-    async exportTemplate(params) {
-        return this.request('/automations/export', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Export automation run for debugging
-     * Returns the complete run data including execution state, executor outputs, and edge values
-     */
-    async exportRun(params) {
-        return this.request('/automations/export-run', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Stop a running automation
-     * Marks the run as failed and all pending executors as failed.
-     * In-flight executors will complete gracefully.
-     */
-    async stop(params) {
-        return this.request('/automations/stop', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    // ===========================================================================
-    // Recurrence Scheduling
-    // ===========================================================================
-    /**
-     * Get the recurrence status for an automation template
-     * Returns whether the template has a recurrence node, if it's published, and schedule info
-     */
-    async getRecurrenceStatus(params) {
-        return this.request('/automations/recurrence-status', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Publish an automation - enables recurrence scheduling
-     * The automation will run automatically based on its recurrence configuration
-     */
-    async publish(params) {
-        return this.request('/automations/publish', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Unpublish an automation - disables recurrence and stops the scheduler workflow
-     * No more scheduled runs will occur until the automation is published again
-     */
-    async unpublish(params) {
-        return this.request('/automations/unpublish', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Run an automation once immediately
-     * If the automation is published, this also updates the schedule (restarts the scheduler)
-     * This is used for the "Run Once" button on recurrence automations
-     */
-    async runOnce(params) {
-        return this.request('/automations/run-once', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-}
-exports.AutomationsClient = AutomationsClient;

package/dist/node-runtime.d.ts

@@ -1,57 +0,0 @@
-/**
- * Runtime types for node execution
- * These types are used during workflow execution
- */
-/**
- * Media type classification
- */
-export type MediaType = 'video' | 'image' | 'audio' | 'text';
-/**
- * Selection mode for source nodes
- */
-export type SelectionMode = 'random' | 'sequential';
-/**
- * Behavior when all items have been used
- */
-export type ExhaustionBehavior = 'restart' | 'error';
-/**
- * Selection configuration for source nodes (image, video, audio)
- */
-export interface SelectionConfig {
-    mode: SelectionMode;
-    enforceUniqueness: boolean;
-    exhaustionBehavior: ExhaustionBehavior;
-}
-/**
- * Runtime state for tracking selection progress (persisted in node config)
- */
-export interface SelectionState {
-    usedIndices: number[];
-    currentIndex: number;
-}
-/**
- * Output mode for source nodes
- * - 'per-input': Generate a unique value for each consumer input (default)
- * - 'single': Use the same value for all consumer inputs
- */
-export type OutputMode = 'per-input' | 'single';
-/**
- * Output node input configuration
- */
-export interface OutputInput {
-    id: string;
-    title: string;
-    type: MediaType;
-    tag?: string;
-}
-/**
- * Output node configuration
- */
-export interface OutputNodeConfig {
-    inputs: OutputInput[];
-    saveToMedia: boolean;
-    globalTag?: string;
-    makeUnique: boolean;
-    createPost?: boolean;
-    requireReview?: boolean;
-}

package/dist/node-runtime.js

@@ -1,6 +0,0 @@
-"use strict";
-/**
- * Runtime types for node execution
- * These types are used during workflow execution
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/account.d.ts

@@ -1,7 +0,0 @@
-declare const definition: import("./types").NodeDefinition<"source", {
-    accountIds: never[];
-    outputMode: "per-input";
-    selectionMode: "random";
-}>;
-export default definition;
-export type AccountConfig = typeof definition.defaults;

package/dist/nodes/account.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'account',
-    label: 'Account',
-    description: 'Select accounts to post from',
-    type: 'source',
-    category: 'Sources',
-    outputModes: ['per-input', 'single'],
-    selectionModes: ['random', 'sequential'],
-    defaults: {
-        accountIds: [],
-        outputMode: 'per-input',
-        selectionMode: 'random',
-    },
-    computePorts: () => ({
-        inputs: [],
-        outputs: [
-            {
-                id: 'account',
-                type: 'account',
-                isArray: false,
-                required: true,
-            },
-        ],
-    }),
-});
-exports.default = definition;

package/dist/nodes/auto-caption.d.ts

@@ -1,17 +0,0 @@
-declare const definition: import("./types").NodeDefinition<"generator", {
-    fontName: string;
-    fontSize: number;
-    fontWeight: string;
-    fontColor: string;
-    highlightColor: string;
-    strokeColor: string;
-    strokeWidth: number;
-    position: string;
-    wordsPerSubtitle: number;
-    enableAnimation: boolean;
-    language: string;
-    outputMode: "per-input";
-    selectionMode: null;
-}>;
-export default definition;
-export type AutoCaptionConfig = typeof definition.defaults;

package/dist/nodes/auto-caption.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'auto-caption',
-    label: 'Auto Caption',
-    description: 'Add TikTok-style captions to videos',
-    type: 'generator',
-    category: 'Generation',
-    outputModes: ['per-input', 'single'],
-    selectionModes: null,
-    defaults: {
-        fontName: 'Montserrat',
-        fontSize: 80,
-        fontWeight: 'bold',
-        fontColor: 'white',
-        highlightColor: 'yellow',
-        strokeColor: 'black',
-        strokeWidth: 3,
-        position: 'bottom',
-        wordsPerSubtitle: 3,
-        enableAnimation: true,
-        language: 'en',
-        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/auto-post.d.ts

@@ -1,21 +0,0 @@
-import type { InputType } from './types';
-type AutoPostMode = 'video' | 'slideshow';
-declare const definition: import("./types").NodeDefinition<"terminal", {
-    mode: AutoPostMode;
-    inputType: InputType;
-    inputs: Array<{
-        id: string;
-    }>;
-    socialAudioIsVariable: boolean;
-    schedulingMode: string;
-    minDistanceHours: number;
-    maxPostsPerDay: number;
-    randomWindowStart: string;
-    randomWindowEnd: string;
-    timezone: string;
-    requireApproval: boolean;
-    outputMode: null;
-    selectionMode: null;
-}>;
-export default definition;
-export type AutoPostConfig = typeof definition.defaults;