ugcinc 4.0.2 → 4.1.1

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

@@ -0,0 +1,312 @@
+import type { NodeDefinition } from './types';
+import { internalNodeTypes, type InternalNodeType } from './internal';
+/**
+ * Registry of all user-creatable node definitions.
+ * This is the single source of truth for node types.
+ */
+export declare const nodeDefinitions: {
+    readonly account: NodeDefinition<"source", {
+        accountIds: string[];
+        outputMode: "per-input";
+        selectionMode: "random";
+    }, false>;
+    readonly 'auto-caption': NodeDefinition<"generator", {
+        preset: "hormozi" | "minimal" | "bold-pop" | "clean" | "neon";
+        fontName: string | undefined;
+        fontSize: number | undefined;
+        fontWeight: ("normal" | "bold" | "black") | undefined;
+        fontColor: string | undefined;
+        highlightColor: string | undefined;
+        strokeColor: string | undefined;
+        strokeWidth: number | undefined;
+        backgroundColor: string | undefined;
+        position: ("top" | "center" | "bottom") | 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: "video" | "slideshow";
+        inputType: import("./types").InputType;
+        imageInputs: Array<{
+            id: string;
+        }>;
+        socialAudioIsVariable: boolean;
+        socialAudioSelectedIds: string[];
+        schedulingMode: "scheduled" | "queue";
+        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: "instagram" | "imessage";
+        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
+ */
+export declare function getAllNodeDefinitions(): AnyNodeDefinition[];
+/**
+ * Get a node definition by its nodeId
+ */
+export declare function getNodeDefinition(nodeId: UserCreatableNodeType): AnyNodeDefinition | undefined;

package/dist/automations/nodes/index.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalNodeTypes = exports.nodeDefinitions = void 0;
+exports.getAllNodeDefinitions = getAllNodeDefinitions;
+exports.getNodeDefinition = getNodeDefinition;
+const internal_1 = require("./internal");
+Object.defineProperty(exports, "internalNodeTypes", { enumerable: true, get: function () { return internal_1.internalNodeTypes; } });
+// Import all node definitions
+const account_1 = __importDefault(require("./account"));
+const auto_caption_1 = __importDefault(require("./auto-caption"));
+const auto_post_1 = __importDefault(require("./auto-post"));
+const branch_1 = __importDefault(require("./branch"));
+const collect_1 = __importDefault(require("./collect"));
+const compose_workflow_1 = __importDefault(require("./compose-workflow"));
+const create_dm_1 = __importDefault(require("./create-dm"));
+const custom_model_1 = __importDefault(require("./custom-model"));
+const deduplicate_1 = __importDefault(require("./deduplicate"));
+const destructure_1 = __importDefault(require("./destructure"));
+const for_each_1 = __importDefault(require("./for-each"));
+const generate_image_1 = __importDefault(require("./generate-image"));
+const generate_video_1 = __importDefault(require("./generate-video"));
+const if_1 = __importDefault(require("./if"));
+const image_composer_1 = __importDefault(require("./image-composer"));
+const llm_1 = __importDefault(require("./llm"));
+const manual_trigger_1 = __importDefault(require("./manual-trigger"));
+const media_1 = __importDefault(require("./media"));
+const not_1 = __importDefault(require("./not"));
+const output_1 = __importDefault(require("./output"));
+const random_1 = __importDefault(require("./random"));
+const random_route_1 = __importDefault(require("./random-route"));
+const recurrence_1 = __importDefault(require("./recurrence"));
+const save_to_media_1 = __importDefault(require("./save-to-media"));
+const screenshot_animation_1 = __importDefault(require("./screenshot-animation"));
+const social_audio_1 = __importDefault(require("./social-audio"));
+const text_1 = __importDefault(require("./text"));
+const transcript_1 = __importDefault(require("./transcript"));
+const video_composer_1 = __importDefault(require("./video-composer"));
+const video_import_1 = __importDefault(require("./video-import"));
+// =============================================================================
+// Registry
+// =============================================================================
+/**
+ * Registry of all user-creatable node definitions.
+ * This is the single source of truth for node types.
+ */
+exports.nodeDefinitions = {
+    'account': account_1.default,
+    'auto-caption': auto_caption_1.default,
+    'auto-post': auto_post_1.default,
+    'branch': branch_1.default,
+    'collect': collect_1.default,
+    'compose-workflow': compose_workflow_1.default,
+    'create-dm': create_dm_1.default,
+    'custom-model': custom_model_1.default,
+    'deduplicate': deduplicate_1.default,
+    'destructure': destructure_1.default,
+    'for-each': for_each_1.default,
+    'generate-image': generate_image_1.default,
+    'generate-video': generate_video_1.default,
+    'if': if_1.default,
+    'image-composer': image_composer_1.default,
+    'llm': llm_1.default,
+    'manual-trigger': manual_trigger_1.default,
+    'media': media_1.default,
+    'not': not_1.default,
+    'passthrough': output_1.default,
+    'random': random_1.default,
+    'random-route': random_route_1.default,
+    'recurrence': recurrence_1.default,
+    'save-to-media': save_to_media_1.default,
+    'screenshot-animation': screenshot_animation_1.default,
+    'social-audio': social_audio_1.default,
+    'text': text_1.default,
+    'transcript': transcript_1.default,
+    'video-composer': video_composer_1.default,
+    'video-import': video_import_1.default,
+};
+/**
+ * Get all node definitions as an array
+ */
+function getAllNodeDefinitions() {
+    return Object.values(exports.nodeDefinitions);
+}
+/**
+ * Get a node definition by its nodeId
+ */
+function getNodeDefinition(nodeId) {
+    return exports.nodeDefinitions[nodeId];
+}

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

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

package/dist/automations/nodes/internal.js

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

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

@@ -0,0 +1,26 @@
+import { type ObjectSchemaField } from './types';
+declare const LLMProviders: readonly ["groq", "openai", "claude", "gemini"];
+type LLMProvider = typeof LLMProviders[number];
+interface LLMApiKeys {
+    openai?: string;
+    claude?: string;
+    gemini?: string;
+    groq?: string;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    provider: LLMProvider;
+    model: string;
+    temperature: number;
+    maxTokens: number | undefined;
+    systemPrompt: string;
+    outputFields: ObjectSchemaField[];
+    useStructuredOutput: boolean;
+    imageInputRefs: string[];
+    videoInputRefs: string[];
+    apiKeys: LLMApiKeys | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;
+export { LLMProviders };
+export type { LLMProvider, LLMApiKeys };

package/dist/automations/nodes/llm.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMProviders = void 0;
+const internal_utils_1 = require("../../internal-utils");
+const types_1 = require("./types");
+const LLMProviders = ['groq', 'openai', 'claude', 'gemini'];
+exports.LLMProviders = LLMProviders;
+const definition = (0, types_1.defineNode)({
+    nodeId: 'llm',
+    label: 'LLM',
+    description: 'Generate LLM output',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        provider: 'claude',
+        model: 'claude-sonnet-4-5',
+        temperature: 0.7,
+        maxTokens: undefined,
+        systemPrompt: '',
+        outputFields: [{ name: 'output', type: 'string' }],
+        useStructuredOutput: true,
+        imageInputRefs: [],
+        videoInputRefs: [],
+        apiKeys: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        // Input ports from template variables + media refs
+        const systemPrompt = config?.systemPrompt ?? '';
+        const variables = (0, internal_utils_1.extractTemplateVariables)([systemPrompt]);
+        const imageInputRefs = config?.imageInputRefs ?? [];
+        const videoInputRefs = config?.videoInputRefs ?? [];
+        const inputs = [
+            ...variables.map(v => ({
+                id: v,
+                type: ['text', 'object', 'boolean'],
+                isArray: false,
+                required: true,
+            })),
+            ...imageInputRefs.map(ref => ({
+                id: ref,
+                type: 'image',
+                isArray: false,
+                required: true,
+            })),
+            ...videoInputRefs.map(ref => ({
+                id: ref,
+                type: 'video',
+                isArray: false,
+                required: true,
+            })),
+        ];
+        // Output ports from outputFields
+        const outputFields = (config?.outputFields ?? [{ name: 'output', type: 'string' }]);
+        const outputs = outputFields.map(f => {
+            let pType;
+            let pIsArray;
+            if (f.type === 'array') {
+                pType = f.items === 'object' ? 'object' : 'text';
+                pIsArray = true;
+            }
+            else if (f.type === 'object') {
+                pType = 'object';
+                pIsArray = false;
+            }
+            else {
+                pType = 'text';
+                pIsArray = false;
+            }
+            return {
+                id: f.name,
+                type: pType,
+                isArray: pIsArray,
+                required: f.required ?? true,
+                // Include objectSchema for object/array-of-object types
+                ...(f.objectSchema && { objectSchema: f.objectSchema }),
+            };
+        });
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,14 @@
+import type { BasePortType, EnumOption } from '../types';
+import { type ObjectSchemaField } from './types';
+declare const definition: import("./types").NodeDefinition<"trigger", {
+    outputs: Array<{
+        id: string;
+        type: BasePortType;
+        isArray?: boolean;
+        objectSchema?: ObjectSchemaField[];
+        enumOptions?: EnumOption[];
+    }>;
+    outputMode: null;
+    selectionMode: null;
+}, false>;
+export default definition;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'manual-trigger',
+    label: 'Manual Trigger',
+    description: 'Trigger manually',
+    type: 'trigger',
+    category: 'Triggers',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        outputs: [{ id: 'input-1', type: 'image' }],
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const configOutputs = config?.outputs ?? [];
+        const outputs = configOutputs.map(output => ({
+            id: output.id,
+            type: output.type,
+            isArray: output.isArray ?? false,
+            required: true,
+            ...(output.type === 'enum' && output.enumOptions ? { enumOptions: output.enumOptions } : {}),
+        }));
+        return {
+            inputs: [],
+            outputs,
+        };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,13 @@
+import { type SelectionConfig, type MediaNodeSelectionType } from './types';
+declare const definition: import("./types").NodeDefinition<"source", {
+    outputs: {
+        id: string;
+        type: MediaNodeSelectionType;
+        isArray: boolean;
+        selectedMediaIds: string[];
+        selectionConfig: SelectionConfig | undefined;
+    }[];
+    outputMode: "per-input";
+    selectionMode: "random";
+}, false>;
+export default definition;

package/dist/automations/nodes/media.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'media',
+    label: 'Media',
+    description: 'Use saved media',
+    type: 'source',
+    category: 'Sources',
+    outputModes: ['per-input', 'single'],
+    selectionModes: ['random', 'sequential'],
+    defaults: {
+        outputs: [{
+                id: 'image-1',
+                type: 'image',
+                isArray: false,
+                selectedMediaIds: [],
+                selectionConfig: undefined,
+            }],
+        outputMode: 'per-input',
+        selectionMode: 'random',
+    },
+    computePorts: ({ config }) => {
+        const outputConfigs = config?.outputs ?? [];
+        // Generate output ports from config (only those with selected media)
+        const outputs = outputConfigs
+            .filter(o => o.selectedMediaIds.length > 0)
+            .map(o => ({
+            id: o.id,
+            type: o.type,
+            isArray: o.isArray,
+            required: true,
+        }));
+        return {
+            inputs: [],
+            outputs,
+        };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,5 @@
+declare const definition: import("./types").NodeDefinition<"generator", {
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/not.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'not',
+    label: 'Not',
+    description: 'Invert a boolean value',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'input',
+                type: 'boolean',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'output',
+                type: 'boolean',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;