@mindstudio-ai/agent 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,4727 @@
+interface HttpClientConfig {
+    baseUrl: string;
+    token: string;
+}
+
+/** Configuration options for creating a {@link MindStudioAgent}. */
+interface AgentOptions {
+    /**
+     * MindStudio API key. Used as a Bearer token for authentication.
+     *
+     * If omitted, the SDK looks for `MINDSTUDIO_API_KEY` in the environment,
+     * then falls back to `CALLBACK_TOKEN` (available automatically
+     * inside MindStudio custom functions).
+     */
+    apiKey?: string;
+    /**
+     * Base URL of the MindStudio API.
+     *
+     * If omitted, the SDK looks for `MINDSTUDIO_BASE_URL` in the environment,
+     * then `REMOTE_HOSTNAME` (available automatically inside MindStudio
+     * custom functions), then falls back to `https://v1.mindstudio-api.com`.
+     */
+    baseUrl?: string;
+}
+/** Options for a single step execution call. */
+interface StepExecutionOptions {
+    /**
+     * App ID to execute within. When using an API key, omit this to let the
+     * API create a service account app automatically. Pass a previously returned
+     * `appId` to reuse an existing app context.
+     */
+    appId?: string;
+    /**
+     * Thread ID for state persistence across calls. Omit to create an ephemeral
+     * thread. Pass a previously returned `threadId` to maintain conversation
+     * history or variable state.
+     */
+    threadId?: string;
+}
+/** Result of a step execution call. */
+interface StepExecutionResult<TOutput = unknown> {
+    /** The step's output data. */
+    output: TOutput;
+    /**
+     * Signed URL to fetch the output from S3.
+     * Present only when the output was too large to inline in the response body.
+     */
+    outputUrl?: string;
+    /** The app ID used for this execution. Pass to subsequent calls to reuse. */
+    appId: string;
+    /** The thread ID used for this execution. Pass to subsequent calls to maintain state. */
+    threadId: string;
+}
+
+interface ActiveCampaignAddNoteStepInput {
+    /** ActiveCampaign contact ID to add the note to */
+    contactId: string;
+    /** Note text content */
+    note: string;
+    /** ActiveCampaign OAuth connection ID */
+    connectionId: string;
+}
+type ActiveCampaignAddNoteStepOutput = unknown;
+interface ActiveCampaignCreateContactStepInput {
+    /** Contact email address */
+    email: string;
+    /** Contact first name */
+    firstName: string;
+    /** Contact last name */
+    lastName: string;
+    /** Contact phone number */
+    phone: string;
+    /** ActiveCampaign account ID to associate the contact with */
+    accountId: string;
+    /** Custom field values keyed by field ID */
+    customFields: Record<string, unknown>;
+    /** ActiveCampaign OAuth connection ID */
+    connectionId: string;
+    /** Variable name to store the created contact ID */
+    destinationVar?: string;
+}
+interface ActiveCampaignCreateContactStepOutput {
+    /** ActiveCampaign contact ID of the created contact */
+    contactId: string;
+}
+interface AddSubtitlesToVideoStepInput {
+    /** URL of the source video */
+    videoUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** ISO language code for subtitle transcription */
+    language: string;
+    /** Google Font name for subtitle text */
+    fontName: string;
+    /** Font size in pixels. Default: 100. */
+    fontSize: number;
+    /** Font weight for subtitle text */
+    fontWeight: "normal" | "bold" | "black";
+    /** Color of the subtitle text */
+    fontColor: "white" | "black" | "red" | "green" | "blue" | "yellow" | "orange" | "purple" | "pink" | "brown" | "gray" | "cyan" | "magenta";
+    /** Color used to highlight the currently spoken word */
+    highlightColor: "white" | "black" | "red" | "green" | "blue" | "yellow" | "orange" | "purple" | "pink" | "brown" | "gray" | "cyan" | "magenta";
+    /** Width of the text stroke outline in pixels */
+    strokeWidth: number;
+    /** Color of the text stroke outline */
+    strokeColor: "black" | "white" | "red" | "green" | "blue" | "yellow" | "orange" | "purple" | "pink" | "brown" | "gray" | "cyan" | "magenta";
+    /** Background color behind subtitle text. Use 'none' for transparent. */
+    backgroundColor: "black" | "white" | "red" | "green" | "blue" | "yellow" | "orange" | "purple" | "pink" | "brown" | "gray" | "cyan" | "magenta" | "none";
+    /** Opacity of the subtitle background. 0.0 = fully transparent, 1.0 = fully opaque. */
+    backgroundOpacity: number;
+    /** Vertical position of subtitle text on screen */
+    position: "top" | "center" | "bottom";
+    /** Vertical offset in pixels from the position. Positive moves down, negative moves up. Default: 75. */
+    yOffset: number;
+    /** Maximum number of words per subtitle segment. Use 1 for single-word display, 2-3 for short phrases, or 8-12 for full sentences. Default: 3. */
+    wordsPerSubtitle: number;
+    /** When true, enables bounce-style entrance animation for subtitles. Default: true. */
+    enableAnimation: boolean;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface AddSubtitlesToVideoStepOutput {
+    /** URL of the video with subtitles added */
+    videoUrl: string;
+}
+interface AirtableCreateUpdateRecordStepInput {
+    /** Variable name to store the created/updated record ID */
+    destinationVar?: string;
+    /** Airtable OAuth connection ID */
+    connectionId: string;
+    /** Airtable base ID */
+    baseId: string;
+    /** Airtable table ID */
+    tableId: string;
+    /** Record ID to update. Omit to create a new record */
+    recordId?: string;
+    /** How to handle unspecified fields on update. 'onlySpecified' leaves them as-is, 'all' clears them */
+    updateMode?: "onlySpecified" | "all";
+    /** Field schema metadata used for type resolution */
+    fields: unknown;
+    /** Field values to set, keyed by field ID */
+    recordData: Record<string, unknown>;
+}
+interface AirtableCreateUpdateRecordStepOutput {
+    /** The Airtable record ID of the created or updated record */
+    recordId: string;
+}
+interface AirtableDeleteRecordStepInput {
+    /** Airtable OAuth connection ID */
+    connectionId: string;
+    /** Variable name to store the result */
+    destinationVar?: string;
+    /** Airtable base ID */
+    baseId: string;
+    /** Airtable table ID */
+    tableId: string;
+    /** Record ID to delete */
+    recordId: string;
+}
+interface AirtableDeleteRecordStepOutput {
+    /** Whether the record was successfully deleted */
+    deleted: boolean;
+}
+interface AirtableGetRecordStepInput {
+    /** Airtable OAuth connection ID */
+    connectionId: string;
+    /** Variable name to store the JSON result */
+    destinationVar?: string;
+    /** Airtable base ID (e.g. "appXXXXXX") */
+    baseId: string;
+    /** Airtable table ID (e.g. "tblXXXXXX") */
+    tableId: string;
+    /** Record ID to fetch (e.g. "recXXXXXX") */
+    recordId: string;
+}
+interface AirtableGetRecordStepOutput {
+    /** The retrieved Airtable record, or null if not found */
+    record: {
+        /** Airtable record ID */
+        id: string;
+        /** ISO 8601 timestamp when the record was created */
+        createdTime: string;
+        /** Field values keyed by field name */
+        fields: Record<string, unknown>;
+    } | null;
+}
+interface AirtableGetTableRecordsStepInput {
+    /** Airtable OAuth connection ID */
+    connectionId: string;
+    /** Variable name to store the result */
+    destinationVar?: string;
+    /** Airtable base ID (e.g. "appXXXXXX") */
+    baseId: string;
+    /** Airtable table ID (e.g. "tblXXXXXX") */
+    tableId: string;
+    /** Output format for the result. Defaults to 'json' */
+    outputFormat?: "json" | "csv";
+    /** Maximum number of records to return. Defaults to 100, max 1000 */
+    limit?: number;
+}
+interface AirtableGetTableRecordsStepOutput {
+    /** The list of records retrieved from the Airtable table */
+    records: {
+        /** Airtable record ID */
+        id: string;
+        /** ISO 8601 timestamp when the record was created */
+        createdTime: string;
+        /** Field values keyed by field name */
+        fields: Record<string, unknown>;
+    }[];
+}
+interface AnalyzeImageStepInput {
+    /** Instructions describing what to look for or extract from the image */
+    prompt: string;
+    /** URL of the image to analyze */
+    imageUrl: string;
+    /** Variable name to save the analysis text into */
+    destinationVar?: string;
+    /** Optional model configuration override. Uses the workflow's default vision model if not specified */
+    visionModelOverride?: {
+        model: string;
+        config?: Record<string, unknown>;
+    } | {
+        /** Model identifier (e.g. "gpt-4", "claude-3-opus") */
+        model: string;
+        /** Sampling temperature for the model (0-2) */
+        temperature: number;
+        /** Maximum number of tokens in the model's response */
+        maxResponseTokens: number;
+        /** Whether to skip the system preamble/instructions */
+        ignorePreamble?: boolean;
+        /** Preprocessor applied to user messages before sending to the model */
+        userMessagePreprocessor?: {
+            /** Data source identifier for the preprocessor */
+            dataSource?: string;
+            /** Template string applied to user messages before sending to the model */
+            messageTemplate?: string;
+            /** Maximum number of results to include from the data source */
+            maxResults?: number;
+            /** Whether the preprocessor is active */
+            enabled?: boolean;
+            /** Whether child steps should inherit this preprocessor configuration */
+            shouldInherit?: boolean;
+        };
+        /** System preamble/instructions for the model */
+        preamble?: string;
+        /** Whether multi-model candidate generation is enabled */
+        multiModelEnabled?: boolean;
+        /** Whether the user can edit the model's response */
+        editResponseEnabled?: boolean;
+        /** Additional model-specific configuration */
+        config?: Record<string, unknown>;
+    };
+}
+interface AnalyzeImageStepOutput {
+    /** Text analysis of the image generated by the vision model */
+    analysis: string;
+}
+interface AnalyzeVideoStepInput {
+    /** Instructions describing what to look for or extract from the video */
+    prompt: string;
+    /** URL of the video to analyze */
+    videoUrl: string;
+    /** Variable name to save the analysis text into */
+    destinationVar?: string;
+    /** Optional model configuration override. Uses the workflow's default video analysis model if not specified */
+    videoAnalysisModelOverride?: {
+        model: string;
+        config?: Record<string, unknown>;
+    } | {
+        /** Model identifier (e.g. "gpt-4", "claude-3-opus") */
+        model: string;
+        /** Sampling temperature for the model (0-2) */
+        temperature: number;
+        /** Maximum number of tokens in the model's response */
+        maxResponseTokens: number;
+        /** Whether to skip the system preamble/instructions */
+        ignorePreamble?: boolean;
+        /** Preprocessor applied to user messages before sending to the model */
+        userMessagePreprocessor?: {
+            /** Data source identifier for the preprocessor */
+            dataSource?: string;
+            /** Template string applied to user messages before sending to the model */
+            messageTemplate?: string;
+            /** Maximum number of results to include from the data source */
+            maxResults?: number;
+            /** Whether the preprocessor is active */
+            enabled?: boolean;
+            /** Whether child steps should inherit this preprocessor configuration */
+            shouldInherit?: boolean;
+        };
+        /** System preamble/instructions for the model */
+        preamble?: string;
+        /** Whether multi-model candidate generation is enabled */
+        multiModelEnabled?: boolean;
+        /** Whether the user can edit the model's response */
+        editResponseEnabled?: boolean;
+        /** Additional model-specific configuration */
+        config?: Record<string, unknown>;
+    };
+}
+interface AnalyzeVideoStepOutput {
+    /** Text analysis of the video generated by the video analysis model */
+    analysis: string;
+}
+interface CaptureThumbnailStepInput {
+    /** URL of the source video to capture a frame from */
+    videoUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** Timestamp in seconds to capture the frame, or 'last' for the final frame */
+    at: number | string;
+}
+interface CaptureThumbnailStepOutput {
+    /** URL of the captured thumbnail image */
+    thumbnailUrl: string;
+}
+interface CodaCreateUpdatePageStepInput {
+    /** Variable name to store the created/updated page ID */
+    destinationVar?: string;
+    /** Coda OAuth connection ID */
+    connectionId: string;
+    /** Page configuration including document ID, title, content, and optional parent page */
+    pageData: {
+        /** Coda document ID */
+        docId: string;
+        /** Page ID to update. Omit to create a new page */
+        pageId?: string;
+        /** Page title */
+        name: string;
+        /** Page subtitle */
+        subtitle: string;
+        /** Page icon name */
+        iconName: string;
+        /** Page cover image URL */
+        imageUrl: string;
+        /** Parent page ID for nesting under another page */
+        parentPageId?: string;
+        /** Page content (markdown string or canvas content object) */
+        pageContent: string | unknown;
+        /** Content update payload for partial updates */
+        contentUpdate?: unknown;
+        /** How to insert content on update: "append" or "replace" */
+        insertionMode?: string;
+    };
+}
+interface CodaCreateUpdatePageStepOutput {
+    /** The Coda page ID of the created or updated page */
+    pageId: string;
+}
+interface CodaCreateUpdateRowStepInput {
+    /** Variable name to store the created/updated row ID */
+    destinationVar?: string;
+    /** Coda OAuth connection ID */
+    connectionId: string;
+    /** Coda document ID */
+    docId: string;
+    /** Table ID within the document */
+    tableId: string;
+    /** Row ID to update. Omit to create a new row */
+    rowId?: string;
+    /** Column values to set, keyed by column ID */
+    rowData: Record<string, unknown>;
+}
+interface CodaCreateUpdateRowStepOutput {
+    /** The Coda row ID of the created or updated row */
+    rowId: string;
+}
+interface CodaFindRowStepInput {
+    /** Variable name to store the found row as JSON */
+    destinationVar?: string;
+    /** Coda OAuth connection ID */
+    connectionId: string;
+    /** Coda document ID */
+    docId: string;
+    /** Table ID to search within */
+    tableId: string;
+    /** Column values to match against, keyed by column ID. All criteria are ANDed together */
+    rowData: Record<string, unknown>;
+}
+interface CodaFindRowStepOutput {
+    /** The first matching row, or null if no match was found */
+    row: {
+        /** Coda row ID */
+        id: string;
+        /** Column values keyed by column name */
+        values: Record<string, unknown>;
+    } | null;
+}
+interface CodaGetPageStepInput {
+    /** Variable name to store the page content */
+    destinationVar?: string;
+    /** Coda OAuth connection ID */
+    connectionId: string;
+    /** Coda document ID */
+    docId: string;
+    /** Page ID within the document */
+    pageId: string;
+    /** Export format for the page content. Defaults to 'html' */
+    outputFormat?: "html" | "markdown";
+}
+interface CodaGetPageStepOutput {
+    /** Page content in the requested format (HTML or Markdown) */
+    content: string;
+}
+interface CodaGetTableRowsStepInput {
+    /** Variable name to store the result */
+    destinationVar?: string;
+    /** Coda OAuth connection ID */
+    connectionId: string;
+    /** Coda document ID */
+    docId: string;
+    /** Table ID within the document */
+    tableId: string;
+    /** Maximum number of rows to return. Defaults to 10000 */
+    limit?: number | string;
+    /** Output format for the result. Defaults to 'json' */
+    outputFormat?: "json" | "csv";
+}
+interface CodaGetTableRowsStepOutput {
+    /** The list of rows retrieved from the Coda table */
+    rows: {
+        /** Coda row ID */
+        id: string;
+        /** Column values keyed by column name */
+        values: Record<string, unknown>;
+    }[];
+}
+interface ConvertPdfToImagesStepInput {
+    /** URL of the PDF document to convert */
+    pdfUrl: string;
+    /** Variable name to save the array of image URLs into */
+    destinationVar?: string;
+}
+interface ConvertPdfToImagesStepOutput {
+    /** CDN URLs of the generated page images, one per page of the PDF */
+    imageUrls: string[];
+}
+interface CreateGoogleCalendarEventStepInput {
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** Event title */
+    summary: string;
+    /** Event description */
+    description?: string;
+    /** Event location */
+    location?: string;
+    /** Start time in ISO 8601 format */
+    startDateTime: string;
+    /** End time in ISO 8601 format */
+    endDateTime: string;
+    /** Attendee email addresses, one per line */
+    attendees?: string;
+    /** Variable to store the result (JSON with eventId and htmlLink) */
+    destinationVar?: string;
+    /** Whether to attach a Google Meet video call link */
+    addMeetLink?: boolean;
+    /** Calendar ID (defaults to "primary" if omitted) */
+    calendarId?: string;
+}
+interface CreateGoogleCalendarEventStepOutput {
+    /** Google Calendar event ID */
+    eventId: string;
+    /** URL to view the event in Google Calendar */
+    htmlLink: string;
+}
+interface CreateGoogleDocStepInput {
+    /** Title for the new document */
+    title: string;
+    /** Document body content */
+    text: string;
+    /** Variable to store the resulting document URL */
+    destinationVar?: string;
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** Format of the text field: "plain", "html", or "markdown" */
+    textType: "plain" | "html" | "markdown";
+}
+interface CreateGoogleDocStepOutput {
+    /** URL of the newly created Google Document */
+    documentUrl: string;
+}
+interface CreateGoogleSheetStepInput {
+    /** Title for the new spreadsheet */
+    title: string;
+    /** CSV data to populate the sheet with */
+    text: string;
+    /** Variable to store the resulting spreadsheet URL */
+    destinationVar?: string;
+    /** Google OAuth connection ID */
+    connectionId: string;
+}
+interface CreateGoogleSheetStepOutput {
+    /** URL of the newly created Google Spreadsheet */
+    spreadsheetUrl: string;
+}
+interface DeleteGoogleCalendarEventStepInput {
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** Google Calendar event ID to delete */
+    eventId: string;
+    /** Calendar ID (defaults to "primary" if omitted) */
+    calendarId?: string;
+}
+type DeleteGoogleCalendarEventStepOutput = unknown;
+interface DetectPIIStepInput {
+    /** Text to scan for personally identifiable information */
+    input: string;
+    /** Language code of the input text (e.g. "en") */
+    language: string;
+    /** PII entity types to scan for (e.g. ["PHONE_NUMBER", "EMAIL_ADDRESS"]). Empty array means nothing is scanned. */
+    entities: string[];
+    /** Step to transition to if PII is detected (workflow mode) */
+    detectedStepId?: string;
+    /** Step to transition to if no PII is detected (workflow mode) */
+    notDetectedStepId?: string;
+    /** Variable name to store the raw detection results */
+    outputLogVariable?: string | null;
+}
+interface DetectPIIStepOutput {
+    /** Whether any PII was found in the input text */
+    detected: boolean;
+    /** List of detected PII entities with type, location, and confidence */
+    detections: {
+        /** PII entity type (e.g. "PHONE_NUMBER", "EMAIL_ADDRESS", "PERSON") */
+        entity_type: string;
+        /** Start character index in the input text */
+        start: number;
+        /** End character index in the input text */
+        end: number;
+        /** Confidence score between 0 and 1 */
+        score: number;
+    }[];
+}
+interface DownloadVideoStepInput {
+    /** URL of the video to download (supports YouTube, TikTok, etc. via yt-dlp) */
+    videoUrl: string;
+    /** Output format for the downloaded file */
+    format: "mp4" | "mp3";
+    /** Variable name to store the output URL */
+    destinationVar: string;
+}
+interface DownloadVideoStepOutput {
+    /** URL of the downloaded and re-hosted video file */
+    videoUrl: string;
+}
+interface EnhanceImageGenerationPromptStepInput {
+    /** The raw prompt to enhance */
+    initialPrompt: string;
+    /** Whether to also generate a negative prompt */
+    includeNegativePrompt: boolean;
+    /** Variable name to save the enhanced prompt into */
+    destinationVariableName?: string;
+    /** Variable name to save the negative prompt into */
+    negativePromptDestinationVariableName?: string;
+    /** Custom system prompt for the enhancement model. Uses a default prompt if not provided */
+    systemPrompt: string;
+    /** Model override settings. Leave undefined to use the default model */
+    modelOverride?: unknown;
+}
+interface EnhanceImageGenerationPromptStepOutput {
+    /** The enhanced image generation prompt */
+    prompt: string;
+    /** The negative prompt, only present when includeNegativePrompt was true */
+    negativePrompt?: string;
+}
+interface EnhanceVideoGenerationPromptStepInput {
+    /** The raw prompt to enhance */
+    initialPrompt: string;
+    /** Whether to also generate a negative prompt */
+    includeNegativePrompt: boolean;
+    /** Variable name to save the enhanced prompt into */
+    destinationVariableName?: string;
+    /** Variable name to save the negative prompt into */
+    negativePromptDestinationVariableName?: string;
+    /** Custom system prompt for the enhancement model. Uses a default prompt if not provided */
+    systemPrompt: string;
+    /** Model override settings. Leave undefined to use the default model */
+    modelOverride?: unknown;
+}
+interface EnhanceVideoGenerationPromptStepOutput {
+    /** The enhanced video generation prompt */
+    prompt: string;
+    /** The negative prompt, only present when includeNegativePrompt was true */
+    negativePrompt?: string;
+}
+interface EnrichPersonStepInput {
+    /** Variable name to store the result as JSON */
+    destinationVar?: string;
+    /** Search parameters to identify the person (ID, name, LinkedIn URL, email, or domain) */
+    params: {
+        /** Apollo person ID */
+        id: string;
+        /** Person's full name */
+        name: string;
+        /** LinkedIn profile URL */
+        linkedinUrl: string;
+        /** Email address */
+        email: string;
+        /** Company domain */
+        domain: string;
+    };
+}
+interface EnrichPersonStepOutput {
+    /** Apollo enrichment result with contact details, employment history, and social profiles */
+    data: unknown;
+}
+interface ExtractAudioFromVideoStepInput {
+    /** URL of the source video to extract audio from */
+    videoUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+}
+interface ExtractAudioFromVideoStepOutput {
+    /** URL of the extracted audio MP3 file */
+    audioUrl: string;
+}
+interface ExtractTextStepInput {
+    /** URL or array of URLs to extract text from. Accepts a single URL, comma-separated list, or JSON array */
+    url: string | string[];
+    /** Variable name to save the extracted text into */
+    destinationVar?: string;
+}
+interface ExtractTextStepOutput {
+    /** Extracted text content. A single string for one URL, or an array for multiple URLs */
+    text: string | string[];
+}
+interface FetchGoogleDocStepInput {
+    /** Google Document ID (from the document URL) */
+    documentId: string;
+    /** Variable to store the fetched content */
+    destinationVar?: string;
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** Output format: "html", "markdown", "json", or "plain" */
+    exportType: "html" | "markdown" | "json" | "plain";
+}
+interface FetchGoogleDocStepOutput {
+    /** Document contents in the requested export format */
+    content: string;
+}
+interface FetchGoogleSheetStepInput {
+    /** Google Spreadsheet ID (from the spreadsheet URL) */
+    spreadsheetId: string;
+    /** Cell range in A1 notation (e.g. "Sheet1!A1:C10") */
+    range: string;
+    /** Variable to store the fetched content */
+    destinationVar?: string;
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** Output format: "csv" or "json" */
+    exportType: "csv" | "json";
+}
+interface FetchGoogleSheetStepOutput {
+    /** Spreadsheet data in the requested export format */
+    content: string;
+}
+interface FetchSlackChannelHistoryStepInput {
+    /** Slack OAuth connection ID (leave empty to allow user to select) */
+    connectionId: string;
+    /** Slack channel ID (leave empty to allow user to select a channel) */
+    channelId: string;
+    /** Variable to store the output as JSON */
+    destinationVar?: string;
+    /** Maximum number of messages to return (1-15) */
+    limit?: number;
+    /** Earliest date to include messages from */
+    startDate?: string;
+    /** Latest date to include messages up to */
+    endDate?: string;
+    /** Whether to include images in the output */
+    includeImages?: boolean;
+    /** Whether to include the raw Slack message object (useful for bot messages with complex attachments) */
+    includeRawMessage?: boolean;
+}
+interface FetchSlackChannelHistoryStepOutput {
+    /** List of messages from the channel history */
+    messages: {
+        from: string;
+        content: string;
+        timestamp?: string;
+        images?: string[];
+        rawMessage?: {
+            app_id?: string;
+            assistant_app_thread?: {
+                first_user_thread_reply?: string;
+                title?: string;
+                title_blocks?: unknown[];
+            };
+            attachments?: {
+                actions?: unknown[];
+                app_id?: string;
+                app_unfurl_url?: string;
+                author_icon?: string;
+                author_id?: string;
+                author_link?: string;
+                author_name?: string;
+                author_subname?: string;
+                blocks?: unknown[];
+                bot_id?: string;
+                bot_team_id?: string;
+                callback_id?: string;
+                channel_id?: string;
+                channel_name?: string;
+                channel_team?: string;
+                color?: string;
+                fallback?: string;
+                fields?: unknown[];
+                file_id?: string;
+                filename?: string;
+                files?: unknown[];
+                footer?: string;
+                footer_icon?: string;
+                from_url?: string;
+                hide_border?: boolean;
+                hide_color?: boolean;
+                id?: number;
+                image_bytes?: number;
+                image_height?: number;
+                image_url?: string;
+                image_width?: number;
+                indent?: boolean;
+                is_app_unfurl?: boolean;
+                is_file_attachment?: boolean;
+                is_msg_unfurl?: boolean;
+                is_reply_unfurl?: boolean;
+                is_thread_root_unfurl?: boolean;
+                list?: unknown;
+                list_record?: unknown;
+                list_record_id?: string;
+                list_records?: unknown[];
+                list_schema?: unknown[];
+                list_view?: unknown;
+                list_view_id?: string;
+                message_blocks?: unknown[];
+                metadata?: unknown;
+                mimetype?: string;
+                mrkdwn_in?: string[];
+                msg_subtype?: string;
+                original_url?: string;
+                pretext?: string;
+                preview?: unknown;
+                service_icon?: string;
+                service_name?: string;
+                service_url?: string;
+                size?: number;
+                text?: string;
+                thumb_height?: number;
+                thumb_url?: string;
+                thumb_width?: number;
+                title?: string;
+                title_link?: string;
+                ts?: string;
+                url?: string;
+                video_html?: string;
+                video_html_height?: number;
+                video_html_width?: number;
+                video_url?: string;
+            }[];
+            blocks?: {
+                accessory?: unknown;
+                alt_text?: string;
+                api_decoration_available?: boolean;
+                app_collaborators?: string[];
+                app_id?: string;
+                author_name?: string;
+                block_id?: string;
+                bot_user_id?: string;
+                button_label?: string;
+                call?: unknown;
+                call_id?: string;
+                description?: unknown;
+                developer_trace_id?: string;
+                dispatch_action?: boolean;
+                element?: unknown;
+                elements?: unknown[];
+                expand?: boolean;
+                external_id?: string;
+                fallback?: string;
+                fields?: unknown[];
+                file?: unknown;
+                file_id?: string;
+                function_trigger_id?: string;
+                hint?: unknown;
+                image_bytes?: number;
+                image_height?: number;
+                image_url?: string;
+                image_width?: number;
+                is_animated?: boolean;
+                is_workflow_app?: boolean;
+                label?: unknown;
+                optional?: boolean;
+                owning_team_id?: string;
+                provider_icon_url?: string;
+                provider_name?: string;
+                sales_home_workflow_app_type?: number;
+                share_url?: string;
+                slack_file?: unknown;
+                source?: string;
+                text?: unknown;
+                thumbnail_url?: string;
+                title?: unknown;
+                title_url?: string;
+                trigger_subtype?: string;
+                trigger_type?: string;
+                type?: unknown;
+                url?: string;
+                video_url?: string;
+                workflow_id?: string;
+            }[];
+            bot_id?: string;
+            bot_profile?: {
+                app_id?: string;
+                deleted?: boolean;
+                icons?: unknown;
+                id?: string;
+                name?: string;
+                team_id?: string;
+                updated?: number;
+            };
+            client_msg_id?: string;
+            display_as_bot?: boolean;
+            edited?: {
+                ts?: string;
+                user?: string;
+            };
+            files?: {
+                access?: string;
+                alt_txt?: string;
+                app_id?: string;
+                app_name?: string;
+                attachments?: unknown[];
+                blocks?: unknown[];
+                bot_id?: string;
+                can_toggle_canvas_lock?: boolean;
+                canvas_printing_enabled?: boolean;
+                canvas_template_mode?: string;
+                cc?: unknown[];
+                channel_actions_count?: number;
+                channel_actions_ts?: string;
+                channels?: string[];
+                comments_count?: number;
+                converted_pdf?: string;
+                created?: number;
+                deanimate?: string;
+                deanimate_gif?: string;
+                display_as_bot?: boolean;
+                dm_mpdm_users_with_file_access?: unknown[];
+                duration_ms?: number;
+                edit_link?: string;
+                edit_timestamp?: number;
+                editable?: boolean;
+                editor?: string;
+                editors?: string[];
+                external_id?: string;
+                external_type?: string;
+                external_url?: string;
+                favorites?: unknown[];
+                file_access?: string;
+                filetype?: string;
+                from?: unknown[];
+                groups?: string[];
+                has_more?: boolean;
+                has_more_shares?: boolean;
+                has_rich_preview?: boolean;
+                headers?: unknown;
+                hls?: string;
+                hls_embed?: string;
+                id?: string;
+                image_exif_rotation?: number;
+                ims?: string[];
+                initial_comment?: unknown;
+                is_channel_space?: boolean;
+                is_external?: boolean;
+                is_public?: boolean;
+                is_restricted_sharing_enabled?: boolean;
+                is_starred?: boolean;
+                last_editor?: string;
+                last_read?: number;
+                lines?: number;
+                lines_more?: number;
+                linked_channel_id?: string;
+                list_csv_download_url?: string;
+                list_limits?: unknown;
+                list_metadata?: unknown;
+                media_display_type?: string;
+                media_progress?: unknown;
+                mimetype?: string;
+                mode?: string;
+                mp4?: string;
+                mp4_low?: string;
+                name?: string;
+                non_owner_editable?: boolean;
+                num_stars?: number;
+                org_or_workspace_access?: string;
+                original_attachment_count?: number;
+                original_h?: string;
+                original_w?: string;
+                permalink?: string;
+                permalink_public?: string;
+                pinned_to?: string[];
+                pjpeg?: string;
+                plain_text?: string;
+                pretty_type?: string;
+                preview?: string;
+                preview_highlight?: string;
+                preview_is_truncated?: boolean;
+                preview_plain_text?: string;
+                private_channels_with_file_access_count?: number;
+                private_file_with_access_count?: number;
+                public_url_shared?: boolean;
+                quip_thread_id?: string;
+                reactions?: unknown[];
+                saved?: unknown;
+                sent_to_self?: boolean;
+                shares?: unknown;
+                show_badge?: boolean;
+                simplified_html?: string;
+                size?: number;
+                source_team?: string;
+                subject?: string;
+                subtype?: string;
+                team_pref_version_history_enabled?: boolean;
+                teams_shared_with?: unknown[];
+                template_conversion_ts?: number;
+                template_description?: string;
+                template_icon?: string;
+                template_name?: string;
+                template_title?: string;
+                thumb_1024?: string;
+                thumb_1024_gif?: string;
+                thumb_1024_h?: string;
+                thumb_1024_w?: string;
+                thumb_160?: string;
+                thumb_160_gif?: string;
+                thumb_160_h?: string;
+                thumb_160_w?: string;
+                thumb_360?: string;
+                thumb_360_gif?: string;
+                thumb_360_h?: string;
+                thumb_360_w?: string;
+                thumb_480?: string;
+                thumb_480_gif?: string;
+                thumb_480_h?: string;
+                thumb_480_w?: string;
+                thumb_64?: string;
+                thumb_64_gif?: string;
+                thumb_64_h?: string;
+                thumb_64_w?: string;
+                thumb_720?: string;
+                thumb_720_gif?: string;
+                thumb_720_h?: string;
+                thumb_720_w?: string;
+                thumb_80?: string;
+                thumb_800?: string;
+                thumb_800_gif?: string;
+                thumb_800_h?: string;
+                thumb_800_w?: string;
+                thumb_80_gif?: string;
+                thumb_80_h?: string;
+                thumb_80_w?: string;
+                thumb_960?: string;
+                thumb_960_gif?: string;
+                thumb_960_h?: string;
+                thumb_960_w?: string;
+                thumb_gif?: string;
+                thumb_pdf?: string;
+                thumb_pdf_h?: string;
+                thumb_pdf_w?: string;
+                thumb_tiny?: string;
+                thumb_video?: string;
+                thumb_video_h?: number;
+                thumb_video_w?: number;
+                timestamp?: number;
+                title?: string;
+                title_blocks?: unknown[];
+                to?: unknown[];
+                transcription?: unknown;
+                update_notification?: number;
+                updated?: number;
+                url_private?: string;
+                url_private_download?: string;
+                url_static_preview?: string;
+                user?: string;
+                user_team?: string;
+                username?: string;
+                vtt?: string;
+            }[];
+            icons?: {
+                emoji?: string;
+                image_36?: string;
+                image_48?: string;
+                image_64?: string;
+                image_72?: string;
+            };
+            inviter?: string;
+            is_locked?: boolean;
+            latest_reply?: string;
+            metadata?: {
+                event_payload?: unknown;
+                event_type?: string;
+            };
+            parent_user_id?: string;
+            purpose?: string;
+            reactions?: {
+                count?: number;
+                name?: string;
+                url?: string;
+                users?: string[];
+            }[];
+            reply_count?: number;
+            reply_users?: string[];
+            reply_users_count?: number;
+            root?: {
+                bot_id?: string;
+                icons?: unknown;
+                latest_reply?: string;
+                parent_user_id?: string;
+                reply_count?: number;
+                reply_users?: string[];
+                reply_users_count?: number;
+                subscribed?: boolean;
+                subtype?: string;
+                text?: string;
+                thread_ts?: string;
+                ts?: string;
+                type?: string;
+                username?: string;
+            };
+            subscribed?: boolean;
+            subtype?: string;
+            team?: string;
+            text?: string;
+            thread_ts?: string;
+            topic?: string;
+            ts?: string;
+            type?: string;
+            upload?: boolean;
+            user?: string;
+            username?: string;
+            x_files?: string[];
+        };
+    }[];
+}
+interface FetchYoutubeCaptionsStepInput {
+    /** YouTube video URL to fetch captions for */
+    videoUrl: string;
+    /** Variable name to save the formatted captions */
+    destinationVar?: string;
+    /** Output format: "text" for timestamped plain text, "json" for structured transcript data */
+    exportType: "text" | "json";
+    /** Language code for the captions (e.g. "en") */
+    language: string;
+}
+interface FetchYoutubeCaptionsStepOutput {
+    /** Parsed transcript segments with text and start timestamps */
+    transcripts: {
+        /** Transcript text segment */
+        text: string;
+        /** Start time of the segment in seconds */
+        start: number;
+    }[];
+}
+interface FetchYoutubeChannelStepInput {
+    /** YouTube channel URL (e.g. https://www.youtube.com/@ChannelName or /channel/ID) */
+    channelUrl: string;
+    /** Variable name to save the channel data */
+    destinationVar?: string;
+}
+interface FetchYoutubeChannelStepOutput {
+    /** Channel metadata and video listings */
+    channel: Record<string, unknown>;
+}
+interface FetchYoutubeCommentsStepInput {
+    /** YouTube video URL to fetch comments for */
+    videoUrl: string;
+    /** Variable name to save the formatted comments */
+    destinationVar?: string;
+    /** Output format: "text" for markdown-formatted text, "json" for structured comment data */
+    exportType: "text" | "json";
+    /** Maximum number of comment pages to fetch (1-5) */
+    limitPages: string;
+}
+interface FetchYoutubeCommentsStepOutput {
+    /** List of comments retrieved from the video */
+    comments: {
+        /** Unique comment identifier */
+        id: string;
+        /** Direct URL to the comment */
+        link: string;
+        /** Date the comment was published */
+        publishedDate: string;
+        /** Text content of the comment */
+        text: string;
+        /** Number of likes on the comment */
+        likes: number;
+        /** Number of replies to the comment */
+        replies: number;
+        /** Display name of the comment author */
+        author: string;
+        /** URL to the author's YouTube channel */
+        authorLink: string;
+        /** URL of the author's profile image */
+        authorImg: string;
+    }[];
+}
+interface FetchYoutubeVideoStepInput {
+    /** YouTube video URL to fetch metadata for */
+    videoUrl: string;
+    /** Variable name to save the video data */
+    destinationVar?: string;
+}
+interface FetchYoutubeVideoStepOutput {
+    /** Video metadata including title, description, stats, and channel info */
+    video: Record<string, unknown>;
+}
+interface GenerateChartStepInput {
+    /** Chart configuration including type, data, and rendering options */
+    chart: {
+        /** The type of chart to generate */
+        chartType: "bar" | "line" | "pie";
+        /** Chart.js-compatible JSON data serialized as a string */
+        data: string;
+        /** Image rendering options */
+        options: {
+            /** Image width in pixels (e.g. "500") */
+            width: string;
+            /** Image height in pixels (e.g. "300") */
+            height: string;
+        };
+    };
+    /** Variable name to save the chart image URL into */
+    destinationVar?: string;
+}
+interface GenerateChartStepOutput {
+    /** URL of the generated chart image */
+    chartUrl: string;
+}
+interface GenerateImageStepInput {
+    /** Text prompt describing the image to generate */
+    prompt: string;
+    /** foreground = display to user, background = save URL to variable */
+    mode: "foreground" | "background";
+    /** Variable name to save the generated image URL(s) into */
+    destinationVar?: string;
+    /** If true, the image will not appear in the user's asset history */
+    skipAssetCreation?: boolean;
+    /** Optional model configuration override. Uses the workflow's default image model if not specified */
+    imageModelOverride?: {
+        /** Image generation model identifier */
+        model: string;
+        /** Additional model-specific configuration */
+        config?: Record<string, unknown>;
+    };
+    /** Whether to generate multiple image variants in parallel */
+    generateVariants?: boolean;
+    /** Number of variants to generate (max 10) */
+    numVariants?: number;
+    /** How to handle multiple variants: userSelect prompts the user, saveAll saves all URLs */
+    variantBehavior?: "userSelect" | "saveAll";
+    /** Whether to add a MindStudio watermark to the generated image */
+    addWatermark?: boolean;
+}
+interface GenerateImageStepOutput {
+    /** CDN URL of the generated image, or array of URLs when generating multiple variants */
+    imageUrl: string | string[];
+}
+interface GenerateLipsyncStepInput {
+    /** foreground = display video to user, background = save URL to variable */
+    mode: "foreground" | "background";
+    /** Variable name to save the video URL into (used in background mode) */
+    destinationVar?: string;
+    /** If true, the generated video will not appear in the user's asset history */
+    skipAssetCreation?: boolean;
+    /** Whether to add a MindStudio watermark to the generated video */
+    addWatermark?: boolean;
+    /** Optional model configuration override. Uses the workflow's default lipsync model if not specified */
+    lipsyncModelOverride?: {
+        model: string;
+        config?: Record<string, unknown>;
+    };
+}
+type GenerateLipsyncStepOutput = unknown;
+interface GenerateMusicStepInput {
+    /** The instructions (prompt) for the music generation */
+    text: string;
+    /** foreground = display audio to user, background = save URL to variable */
+    mode: "foreground" | "background";
+    /** Variable name to save the audio URL into (used in background mode) */
+    destinationVar?: string;
+    /** If true, the generated audio will not appear in the user's asset history */
+    skipAssetCreation?: boolean;
+    /** Optional model configuration override. Uses the workflow's default music model if not specified */
+    musicModelOverride?: {
+        model: string;
+        config?: Record<string, unknown>;
+    };
+}
+type GenerateMusicStepOutput = unknown;
+interface GeneratePdfStepInput {
+    /** The HTML or Markdown source template for the asset */
+    source: string;
+    /** Source type: html, markdown (auto-formatted), spa (single page app), raw (pre-generated HTML in a variable), dynamic (AI-generated from prompt), or customInterface */
+    sourceType: "html" | "markdown" | "spa" | "raw" | "dynamic" | "customInterface";
+    /** foreground = display the asset to the user, background = save the URL to a variable */
+    mode: "foreground" | "background";
+    /** Variable name to save the asset URL into (used in background mode) */
+    destinationVar?: string;
+    /** The output format for the generated asset */
+    outputFormat: "pdf" | "png" | "html" | "mp4" | "openGraph";
+    /** Page size for PDF, PNG, or MP4 output */
+    pageSize: "full" | "letter" | "A4" | "custom";
+    /** Test data used for previewing the template with sample variable values */
+    testData: Record<string, unknown>;
+    /** Additional rendering options */
+    options?: {
+        /** Custom page width in pixels (for custom pageSize) */
+        pageWidthPx?: number;
+        /** Custom page height in pixels (for custom pageSize) */
+        pageHeightPx?: number;
+        /** Page orientation for the rendered output */
+        pageOrientation?: "portrait" | "landscape";
+        /** Whether to re-host third-party images on the MindStudio CDN */
+        rehostMedia?: boolean;
+        /** Duration in seconds for MP4 video output */
+        videoDurationSeconds?: number;
+    };
+    /** Single page app source configuration (advanced) */
+    spaSource?: {
+        /** Available route paths in the SPA */
+        paths: string[];
+        /** Root URL of the SPA bundle */
+        root: string;
+        /** URL of the zipped SPA bundle */
+        zipUrl: string;
+    };
+    /** Raw HTML source stored in a variable, using handlebars syntax (e.g. {{myHtmlVariable}}) */
+    rawSource?: string;
+    /** Prompt to generate the HTML dynamically when sourceType is "dynamic" */
+    dynamicPrompt?: string;
+    /** Model override for dynamic HTML generation. Leave undefined to use the default model */
+    dynamicSourceModelOverride?: {
+        /** Model identifier (e.g. "gpt-4", "claude-3-opus") */
+        model: string;
+        /** Sampling temperature for the model (0-2) */
+        temperature: number;
+        /** Maximum number of tokens in the model's response */
+        maxResponseTokens: number;
+        /** Whether to skip the system preamble/instructions */
+        ignorePreamble?: boolean;
+        /** Preprocessor applied to user messages before sending to the model */
+        userMessagePreprocessor?: {
+            /** Data source identifier for the preprocessor */
+            dataSource?: string;
+            /** Template string applied to user messages before sending to the model */
+            messageTemplate?: string;
+            /** Maximum number of results to include from the data source */
+            maxResults?: number;
+            /** Whether the preprocessor is active */
+            enabled?: boolean;
+            /** Whether child steps should inherit this preprocessor configuration */
+            shouldInherit?: boolean;
+        };
+        /** System preamble/instructions for the model */
+        preamble?: string;
+        /** Whether multi-model candidate generation is enabled */
+        multiModelEnabled?: boolean;
+        /** Whether the user can edit the model's response */
+        editResponseEnabled?: boolean;
+        /** Additional model-specific configuration */
+        config?: Record<string, unknown>;
+    };
+    /** Controls how the step transitions after displaying in foreground mode */
+    transitionControl?: "default" | "native";
+    /** Controls visibility of the share button on displayed assets */
+    shareControl?: "default" | "hidden";
+    /** URL of a custom Open Graph share image */
+    shareImageUrl?: string;
+    /** If true, the asset will not appear in the user's asset history */
+    skipAssetCreation?: boolean;
+}
+interface GeneratePdfStepOutput {
+    /** CDN URL of the generated asset (PDF, PNG, HTML, or MP4 depending on outputFormat) */
+    url: string;
+}
+interface GenerateStaticVideoFromImageStepInput {
+    /** URL of the source image to convert to video */
+    imageUrl: string;
+    /** Duration of the output video in seconds */
+    duration: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+}
+interface GenerateStaticVideoFromImageStepOutput {
+    /** URL of the generated static video */
+    videoUrl: string;
+}
+interface GenerateVideoStepInput {
+    /** Text prompt describing the video to generate */
+    prompt: string;
+    /** foreground = display to user, background = save URL to variable */
+    mode: "foreground" | "background";
+    /** Variable name to save the generated video URL(s) into */
+    destinationVar?: string;
+    /** If true, the video will not appear in the user's asset history */
+    skipAssetCreation?: boolean;
+    /** Optional model configuration override. Uses the workflow's default video model if not specified */
+    videoModelOverride?: {
+        /** Video generation model identifier */
+        model: string;
+        /** Additional model-specific configuration */
+        config?: Record<string, unknown>;
+    };
+    /** Whether to generate multiple video variants in parallel */
+    generateVariants?: boolean;
+    /** Number of variants to generate (max 10) */
+    numVariants?: number;
+    /** How to handle multiple variants: userSelect prompts the user, saveAll saves all URLs */
+    variantBehavior?: "userSelect" | "saveAll";
+    /** Whether to add a MindStudio watermark to the generated video */
+    addWatermark?: boolean;
+}
+interface GenerateVideoStepOutput {
+    /** CDN URL of the generated video, or array of URLs when generating multiple variants */
+    videoUrl: string | string[];
+}
+interface GetGoogleCalendarEventStepInput {
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** Google Calendar event ID to retrieve */
+    eventId: string;
+    /** Format for the variable output: "json" or "text" */
+    exportType: "json" | "text";
+    /** Variable to store the result */
+    destinationVar?: string;
+    /** Calendar ID (defaults to "primary" if omitted) */
+    calendarId?: string;
+}
+interface GetGoogleCalendarEventStepOutput {
+    /** The retrieved calendar event */
+    event: {
+        /** Google Calendar event ID */
+        id?: string | null;
+        /** Event status (e.g. "confirmed", "tentative", "cancelled") */
+        status?: string | null;
+        /** URL to view the event in Google Calendar */
+        htmlLink?: string | null;
+        /** Timestamp when the event was created */
+        created?: string | null;
+        /** Timestamp when the event was last updated */
+        updated?: string | null;
+        /** Event title */
+        summary?: string | null;
+        /** Event description */
+        description?: string | null;
+        /** Event location */
+        location?: string | null;
+        /** Event organizer */
+        organizer?: {
+            displayName?: string | null;
+            email?: string | null;
+        } | null;
+        /** Event start time and timezone */
+        start?: {
+            dateTime?: string | null;
+            timeZone?: string | null;
+        } | null;
+        /** Event end time and timezone */
+        end?: {
+            dateTime?: string | null;
+            timeZone?: string | null;
+        } | null;
+        /** List of event attendees */
+        attendees?: ({
+            displayName?: string | null;
+            email?: string | null;
+            responseStatus?: string | null;
+        })[] | null;
+    };
+}
+interface GetMediaMetadataStepInput {
+    /** URL of the audio or video file to analyze */
+    mediaUrl: string;
+    /** Variable name to store the metadata result */
+    destinationVar: string;
+}
+interface GetMediaMetadataStepOutput {
+    /** JSON string containing the media file metadata */
+    metadata: string;
+}
+interface HttpRequestStepInput {
+    /** The request URL */
+    url: string;
+    /** HTTP method (GET, POST, PATCH, DELETE, or PUT) */
+    method: string;
+    /** Custom request headers as key-value pairs */
+    headers: Record<string, unknown>;
+    /** Query string parameters as key-value pairs */
+    queryParams: Record<string, unknown>;
+    /** Raw request body (used for JSON or custom content types) */
+    body: string;
+    /** Key-value body items (used for form data or URL-encoded content types) */
+    bodyItems: Record<string, unknown>;
+    /** The content type for the request body */
+    contentType: "none" | "application/json" | "application/x-www-form-urlencoded" | "multipart/form-data" | "custom";
+    /** Custom Content-Type header value (used when contentType is "custom") */
+    customContentType: string;
+    /** Variable name to save the response body into */
+    destinationVar?: string;
+    /** Test data for debug/preview mode */
+    testData?: Record<string, unknown>;
+}
+interface HttpRequestStepOutput {
+    /** Whether the HTTP response status code is in the 2xx range */
+    ok: boolean;
+    /** HTTP response status code */
+    status: number;
+    /** HTTP response status text */
+    statusText: string;
+    /** Response body as a string */
+    response: string;
+}
+interface HubspotCreateCompanyStepInput {
+    /** HubSpot OAuth connection ID */
+    connectionId: string;
+    /** Variable name to store the company ID */
+    destinationVar?: string;
+    /** Company data including domain, name, and additional properties */
+    company: {
+        /** Company domain, used for matching existing companies */
+        domain: string;
+        /** Company name */
+        name: string;
+    };
+    /** HubSpot properties enabled for this step, used for type validation */
+    enabledProperties: ({
+        /** Display label for the HubSpot property */
+        label: string;
+        /** HubSpot property internal name */
+        value: string;
+        /** Data type of the property value */
+        type: "string" | "number" | "bool";
+    })[];
+}
+interface HubspotCreateCompanyStepOutput {
+    /** HubSpot company ID of the created or updated company */
+    companyId: string;
+}
+interface HubspotCreateContactStepInput {
+    /** HubSpot OAuth connection ID */
+    connectionId: string;
+    /** Variable name to store the contact ID */
+    destinationVar?: string;
+    /** Contact data including email, first name, last name, and additional properties */
+    contact: {
+        /** Contact email address, used for matching existing contacts */
+        email: string;
+        /** Contact first name */
+        firstname: string;
+        /** Contact last name */
+        lastname: string;
+    };
+    /** HubSpot properties enabled for this step, used for type validation */
+    enabledProperties: ({
+        /** Display label for the HubSpot property */
+        label: string;
+        /** HubSpot property internal name */
+        value: string;
+        /** Data type of the property value */
+        type: "string" | "number" | "bool";
+    })[];
+    /** Company domain to associate the contact with. Creates the company if it does not exist */
+    companyDomain: string;
+}
+interface HubspotCreateContactStepOutput {
+    /** HubSpot contact ID of the created or updated contact */
+    contactId: string;
+}
+interface HubspotGetCompanyStepInput {
+    /** HubSpot OAuth connection ID */
+    connectionId: string;
+    /** Variable name to store the result as JSON */
+    destinationVar?: string;
+    /** How to look up the company: by domain name or HubSpot company ID */
+    searchBy: "domain" | "id";
+    /** Domain to search by (used when searchBy is 'domain') */
+    companyDomain: string;
+    /** HubSpot company ID (used when searchBy is 'id') */
+    companyId: string;
+    /** Extra HubSpot property names to include in the response beyond the defaults */
+    additionalProperties: string[];
+}
+interface HubspotGetCompanyStepOutput {
+    /** The retrieved HubSpot company, or null if not found */
+    company: {
+        id: string;
+        properties: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+        archived: boolean;
+    } | null;
+}
+interface HubspotGetContactStepInput {
+    /** HubSpot OAuth connection ID */
+    connectionId: string;
+    /** Variable name to store the result as JSON */
+    destinationVar?: string;
+    /** How to look up the contact: by email address or HubSpot contact ID */
+    searchBy: "email" | "id";
+    /** Email address to search by (used when searchBy is 'email') */
+    contactEmail: string;
+    /** HubSpot contact ID (used when searchBy is 'id') */
+    contactId: string;
+    /** Extra HubSpot property names to include in the response beyond the defaults */
+    additionalProperties: string[];
+}
+interface HubspotGetContactStepOutput {
+    /** The retrieved HubSpot contact, or null if not found */
+    contact: {
+        id: string;
+        properties: Record<string, unknown>;
+        createdAt: string;
+        updatedAt: string;
+        archived: boolean;
+    } | null;
+}
+interface HunterApiCompanyEnrichmentStepInput {
+    /** Domain or URL to look up (e.g. "example.com") */
+    domain: string;
+    /** Variable name to store the result as JSON */
+    destinationVar?: string;
+}
+interface HunterApiCompanyEnrichmentStepOutput {
+    /** Enriched company data, or null if the company was not found */
+    data: {
+        name: string;
+        domain: string;
+        description: string | null;
+        country: string | null;
+        state: string | null;
+        city: string | null;
+        industry: string | null;
+        employees_range: string | null;
+        logo_url: string | null;
+        technologies: string[];
+    } | null;
+}
+interface HunterApiDomainSearchStepInput {
+    /** Domain or URL to search for email addresses (e.g. "example.com") */
+    domain: string;
+    /** Variable name to store the result as JSON */
+    destinationVar?: string;
+}
+interface HunterApiDomainSearchStepOutput {
+    /** Domain search results including emails and organization info */
+    data: {
+        /** The searched domain */
+        domain: string;
+        /** Whether the domain uses disposable email addresses */
+        disposable: boolean;
+        /** Whether the domain is a webmail provider */
+        webmail: boolean;
+        /** Whether the domain accepts all email addresses */
+        accept_all: boolean;
+        /** Common email pattern for the domain (e.g. "{first}.{last}") */
+        pattern: string;
+        /** Organization name associated with the domain */
+        organization: string;
+        /** Country of the organization */
+        country: string | null;
+        /** State or region of the organization */
+        state: string | null;
+        /** List of email addresses found for the domain */
+        emails: ({
+            /** Email address */
+            value: string;
+            /** Email type (e.g. "personal", "generic") */
+            type: string;
+            /** Confidence score (0-100) */
+            confidence: number;
+            /** Contact first name */
+            first_name: string | null;
+            /** Contact last name */
+            last_name: string | null;
+            /** Job title or position */
+            position: string | null;
+            /** Seniority level */
+            seniority: string | null;
+            /** Department within the organization */
+            department: string | null;
+            /** LinkedIn profile URL */
+            linkedin: string | null;
+            /** Twitter handle */
+            twitter: string | null;
+            /** Phone number */
+            phone_number: string | null;
+        })[];
+        /** Other domains linked to this organization */
+        linked_domains: string[];
+    };
+}
+interface HunterApiEmailFinderStepInput {
+    /** Domain to search (e.g. "example.com"). Full URLs are also accepted */
+    domain: string;
+    /** Person's first name */
+    firstName: string;
+    /** Person's last name */
+    lastName: string;
+    /** Variable name to store the result as JSON */
+    destinationVar?: string;
+}
+interface HunterApiEmailFinderStepOutput {
+    /** Email finder results including the found email and confidence score */
+    data: {
+        /** Person's first name */
+        first_name: string;
+        /** Person's last name */
+        last_name: string;
+        /** The found email address */
+        email: string;
+        /** Confidence score (0-100) */
+        score: number;
+        /** Domain searched */
+        domain: string;
+        /** Whether the domain accepts all email addresses */
+        accept_all: boolean;
+        /** Job title or position */
+        position: string | null;
+        /** Twitter handle */
+        twitter: string | null;
+        /** LinkedIn profile URL */
+        linkedin_url: string | null;
+        /** Phone number */
+        phone_number: string | null;
+        /** Company name */
+        company: string | null;
+        /** Sources where the email was found */
+        sources: {
+            /** Domain where the email was found */
+            domain: string;
+            /** URI of the page where the email was found */
+            uri: string;
+            /** Date when the email was extracted */
+            extracted_on: string;
+        }[];
+    };
+}
+interface HunterApiEmailVerificationStepInput {
+    /** Email address to verify */
+    email: string;
+    /** Variable name to store the result as JSON */
+    destinationVar?: string;
+}
+interface HunterApiEmailVerificationStepOutput {
+    /** Email verification results including status, deliverability, and confidence score */
+    data: {
+        /** Verification status (e.g. "valid", "invalid", "accept_all", "webmail", "disposable", "unknown") */
+        status: string;
+        /** Deliverability result */
+        result: string;
+        /** Confidence score (0-100) */
+        score: number;
+        /** The verified email address */
+        email: string;
+        /** Whether the email matches a valid format */
+        regexp: boolean;
+        /** Whether the email appears to be gibberish */
+        gibberish: boolean;
+        /** Whether the email uses a disposable email service */
+        disposable: boolean;
+        /** Whether the email is from a webmail provider */
+        webmail: boolean;
+        /** Whether MX records exist for the domain */
+        mx_records: boolean;
+        /** Whether the SMTP server is reachable */
+        smtp_server: boolean;
+        /** Whether the SMTP mailbox check passed */
+        smtp_check: boolean;
+        /** Whether the domain accepts all email addresses */
+        accept_all: boolean;
+        /** Whether the email is blocked */
+        block: boolean;
+        /** Sources where the email was found */
+        sources: {
+            /** Domain where the email was found */
+            domain: string;
+            /** URI of the page where the email was found */
+            uri: string;
+            /** Date when the email was extracted */
+            extracted_on: string;
+        }[];
+    };
+}
+interface HunterApiPersonEnrichmentStepInput {
+    /** Email address to look up */
+    email: string;
+    /** Variable name to store the result as JSON */
+    destinationVar?: string;
+}
+interface HunterApiPersonEnrichmentStepOutput {
+    /** Enriched person data, or an error object if the person was not found */
+    data: {
+        first_name: string;
+        last_name: string;
+        email: string;
+        position: string | null;
+        seniority: string | null;
+        department: string | null;
+        linkedin_url: string | null;
+        twitter: string | null;
+        phone_number: string | null;
+        company: {
+            name: string;
+            domain: string;
+            industry: string | null;
+        } | null;
+    } | {
+        error: string;
+    };
+}
+interface ImageFaceSwapStepInput {
+    /** URL of the target image containing the face to replace */
+    imageUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar?: string;
+    /** URL of the image containing the replacement face */
+    faceImageUrl: string;
+    /** Face swap engine to use */
+    engine: string;
+}
+interface ImageFaceSwapStepOutput {
+    /** CDN URL of the face-swapped image (PNG) */
+    imageUrl: string;
+}
+interface ImageRemoveWatermarkStepInput {
+    /** URL of the image to remove the watermark from */
+    imageUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar?: string;
+    /** Watermark removal engine to use */
+    engine: string;
+    /** When true, the result will not appear in the user's asset history */
+    skipAssetCreation?: boolean;
+}
+interface ImageRemoveWatermarkStepOutput {
+    /** CDN URL of the processed image with watermark removed (PNG) */
+    imageUrl: string;
+}
+interface InsertVideoClipsStepInput {
+    /** URL of the base video to insert clips into */
+    baseVideoUrl: string;
+    /** Array of overlay clips to insert at specified timecodes */
+    overlayVideos: {
+        /** URL of the overlay video clip */
+        videoUrl: string;
+        /** Timecode in seconds at which to insert this clip */
+        startTimeSec: number;
+    }[];
+    /** Optional xfade transition effect name between clips */
+    transition?: string;
+    /** Duration of the transition in seconds */
+    transitionDuration?: number;
+    /** When true, uses audio from the overlay clips instead of the base video audio during inserts */
+    useOverlayAudio?: boolean;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface InsertVideoClipsStepOutput {
+    /** URL of the video with clips inserted */
+    videoUrl: string;
+}
+interface ListGoogleCalendarEventsStepInput {
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** Maximum number of events to return (default: 10) */
+    limit: number;
+    /** Format for the variable output: "json" or "text" */
+    exportType: "json" | "text";
+    /** Calendar ID (defaults to "primary" if omitted) */
+    calendarId?: string;
+    /** Variable to store the result */
+    destinationVar?: string;
+}
+interface ListGoogleCalendarEventsStepOutput {
+    /** List of upcoming calendar events ordered by start time */
+    events: ({
+        /** Google Calendar event ID */
+        id?: string | null;
+        /** Event status (e.g. "confirmed", "tentative", "cancelled") */
+        status?: string | null;
+        /** URL to view the event in Google Calendar */
+        htmlLink?: string | null;
+        /** Timestamp when the event was created */
+        created?: string | null;
+        /** Timestamp when the event was last updated */
+        updated?: string | null;
+        /** Event title */
+        summary?: string | null;
+        /** Event description */
+        description?: string | null;
+        /** Event location */
+        location?: string | null;
+        /** Event organizer */
+        organizer?: {
+            displayName?: string | null;
+            email?: string | null;
+        } | null;
+        /** Event start time and timezone */
+        start?: {
+            dateTime?: string | null;
+            timeZone?: string | null;
+        } | null;
+        /** Event end time and timezone */
+        end?: {
+            dateTime?: string | null;
+            timeZone?: string | null;
+        } | null;
+        /** List of event attendees */
+        attendees?: ({
+            displayName?: string | null;
+            email?: string | null;
+            responseStatus?: string | null;
+        })[] | null;
+    })[];
+}
+interface LogicStepInput {
+    /** Prompt text providing context for the AI evaluation */
+    context: string;
+    /** List of conditions to evaluate (objects for managed UIs, strings for code) */
+    cases: ({
+        /** Unique case identifier */
+        id: string;
+        /** The statement to evaluate (e.g., "User selected a dog") */
+        condition: string;
+        /** Step to transition to if this case wins (workflow mode only) */
+        destinationStepId?: string;
+    } | string)[];
+}
+interface LogicStepOutput {
+    /** The index of the winning case */
+    selectedCase: number;
+}
+interface MakeDotComRunScenarioStepInput {
+    /** Make.com webhook URL for the scenario */
+    webhookUrl: string;
+    /** Key-value pairs to send as the JSON POST body */
+    input: Record<string, unknown>;
+    /** Variable name to store the scenario response */
+    destinationVar?: string;
+}
+interface MakeDotComRunScenarioStepOutput {
+    /** Response from the Make.com scenario (JSON or string depending on scenario configuration) */
+    data: unknown;
+}
+interface MergeAudioStepInput {
+    /** URLs of the MP3 audio clips to merge in order */
+    mp3Urls: string[];
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** FFmpeg MP3 metadata key-value pairs to embed in the output file */
+    fileMetadata?: Record<string, unknown>;
+    /** URL of an image to embed as album art in the output file */
+    albumArtUrl?: string;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface MergeAudioStepOutput {
+    /** URL of the merged audio file */
+    audioUrl: string;
+}
+interface MergeVideosStepInput {
+    /** URLs of the video clips to merge in order */
+    videoUrls: string[];
+    /** Optional xfade transition effect name */
+    transition?: string;
+    /** Duration of the transition in seconds */
+    transitionDuration?: number;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface MergeVideosStepOutput {
+    /** URL of the merged video */
+    videoUrl: string;
+}
+interface MixAudioIntoVideoStepInput {
+    /** URL of the source video */
+    videoUrl: string;
+    /** URL of the audio track to mix into the video */
+    audioUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** Audio mixing options */
+    options: {
+        /** When true, preserves the original video audio alongside the new track. Defaults to false. */
+        keepVideoAudio?: boolean;
+        /** Volume adjustment for the new audio track in decibels. Defaults to 0. */
+        audioGainDb?: number;
+        /** Volume adjustment for the existing video audio in decibels. Defaults to 0. */
+        videoGainDb?: number;
+        /** When true, loops the audio track to match the video duration. Defaults to false. */
+        loopAudio?: boolean;
+    };
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface MixAudioIntoVideoStepOutput {
+    /** URL of the video with the mixed audio track */
+    videoUrl: string;
+}
+interface MuteVideoStepInput {
+    /** URL of the source video to mute */
+    videoUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface MuteVideoStepOutput {
+    /** URL of the muted video */
+    videoUrl: string;
+}
+interface N8nRunNodeStepInput {
+    /** Variable name to store the response */
+    destinationVar?: string;
+    /** HTTP method to use (GET or POST) */
+    method: string;
+    /** Authentication type for the webhook request */
+    authentication: "none" | "basic" | "string";
+    /** Username for Basic authentication */
+    user: string;
+    /** Password for Basic authentication */
+    password: string;
+    /** n8n webhook URL for the workflow node */
+    webhookUrl: string;
+    /** Key-value pairs sent as query params (GET) or JSON body (POST) */
+    input: Record<string, unknown>;
+}
+interface N8nRunNodeStepOutput {
+    /** Response from the n8n node (JSON or string depending on node configuration) */
+    data: unknown;
+}
+interface NotionCreatePageStepInput {
+    /** Parent page ID to create the new page under */
+    pageId: string;
+    /** Page content in markdown format */
+    content: string;
+    /** Page title */
+    title: string;
+    /** Notion OAuth connection ID */
+    connectionId: string;
+}
+interface NotionCreatePageStepOutput {
+    /** Notion page ID of the created page */
+    pageId: string;
+    /** URL to view the page in Notion */
+    pageUrl: string;
+}
+interface NotionUpdatePageStepInput {
+    /** Notion page ID to update */
+    pageId: string;
+    /** New content in markdown format */
+    content: string;
+    /** How to apply the content: 'append' adds to end, 'overwrite' replaces all existing content */
+    mode: "append" | "overwrite";
+    /** Notion OAuth connection ID */
+    connectionId: string;
+}
+interface NotionUpdatePageStepOutput {
+    /** Notion page ID of the updated page */
+    pageId: string;
+    /** URL to view the page in Notion */
+    pageUrl: string;
+}
+interface PeopleSearchStepInput {
+    /** Variable name to store the search results as JSON */
+    destinationVar: string;
+    /** Natural language search query (e.g. "marketing directors at SaaS companies in NYC") */
+    smartQuery: string;
+    /** Whether to enrich each result with full contact details */
+    enrichPeople: boolean;
+    /** Whether to enrich each result with full company details */
+    enrichOrganizations: boolean;
+    /** Maximum number of results to return */
+    limit: string;
+    /** Page number for pagination */
+    page: string;
+    /** Advanced search filter parameters */
+    params: {
+        /** Job titles to search for (comma-separated) */
+        personTitles: string;
+        /** Whether to include similar/related job titles */
+        includeSimilarTitles: string;
+        /** Keywords to search for in person profiles */
+        qKeywords: string;
+        /** Geographic locations of people (comma-separated) */
+        personLocations: string;
+        /** Seniority levels to filter by (comma-separated) */
+        personSeniorities: string;
+        /** Geographic locations of organizations (comma-separated) */
+        organizationLocations: string;
+        /** Organization domains to filter by (comma-separated) */
+        qOrganizationDomainsList: string;
+        /** Email verification status filter */
+        contactEmailStatus: string;
+        /** Employee count ranges as semicolon-separated pairs (e.g. "1,10; 250,500") */
+        organizationNumEmployeesRanges: string;
+        /** Minimum annual revenue filter */
+        revenueRangeMin: string;
+        /** Maximum annual revenue filter */
+        revenueRangeMax: string;
+        /** Technology UIDs the organization must use (all required) */
+        currentlyUsingAllOfTechnologyUids: string;
+        /** Technology UIDs the organization uses (any match) */
+        currentlyUsingAnyOfTechnologyUids: string;
+        /** Technology UIDs the organization must not use */
+        currentlyNotUsingAnyOfTechnologyUids: string;
+    };
+}
+interface PeopleSearchStepOutput {
+    /** Apollo search results with matched people and optionally enriched data */
+    results: unknown;
+}
+interface PostToLinkedInStepInput {
+    /** The text content of the LinkedIn post */
+    message: string;
+    /** Who can see the post: "PUBLIC" or "CONNECTIONS" */
+    visibility: "PUBLIC" | "CONNECTIONS";
+    /** URL of a video to attach to the post */
+    videoUrl?: string;
+    /** Description text for link/media attachments */
+    descriptionText?: string;
+    /** Title text for link/media attachments */
+    titleText?: string;
+    /** URL of an image to attach to the post */
+    imageUrl?: string;
+    /** LinkedIn OAuth connection ID */
+    connectionId: string;
+}
+type PostToLinkedInStepOutput = unknown;
+interface PostToSlackChannelStepInput {
+    /** Slack channel ID (leave empty to allow user to select a channel) */
+    channelId: string;
+    /** Message format: "string" for plain text/markdown, "blocks" for Slack Block Kit JSON */
+    messageType: "string" | "blocks";
+    /** Message content (plain text/markdown for "string" type, or JSON for "blocks" type) */
+    message: string;
+    /** Slack OAuth connection ID (leave empty to allow user to select) */
+    connectionId: string;
+}
+type PostToSlackChannelStepOutput = unknown;
+interface PostToXStepInput {
+    /** The text content of the post (max 280 characters) */
+    text: string;
+    /** X (Twitter) OAuth connection ID */
+    connectionId: string;
+}
+type PostToXStepOutput = unknown;
+interface PostToZapierStepInput {
+    /** Variable name to store the webhook response */
+    destinationVar?: string;
+    /** Zapier webhook URL to send data to */
+    webhookUrl: string;
+    /** Key-value pairs to send as the JSON POST body */
+    input: Record<string, unknown>;
+}
+interface PostToZapierStepOutput {
+    /** Parsed webhook response from Zapier (JSON object, array, or string) */
+    data: unknown;
+}
+interface QueryDataSourceStepInput {
+    /** ID of the vector data source to query */
+    dataSourceId: string;
+    /** The search query to run against the data source */
+    query: string;
+    /** Variable name to save the joined result text into */
+    destinationVar?: string;
+    /** Maximum number of chunks to return (recommended 1-3) */
+    maxResults: number;
+}
+interface QueryDataSourceStepOutput {
+    /** All matching chunks joined with newlines */
+    text: string;
+    /** Individual matching text chunks from the data source */
+    chunks: string[];
+    /** The resolved search query that was executed */
+    query: string;
+    /** Source citations for the matched chunks */
+    citations: unknown[];
+    /** Query execution time in milliseconds */
+    latencyMs: number;
+}
+interface QueryExternalDatabaseStepInput {
+    /** Database connection ID configured in the workspace */
+    connectionId: string;
+    /** SQL query to execute (supports variable interpolation) */
+    query: string;
+    /** Variable name to save the formatted query result to */
+    destinationVar?: string;
+    /** Output format for the result variable */
+    outputFormat: "json" | "csv";
+}
+interface QueryExternalDatabaseStepOutput {
+    /** Query result rows (array of objects for JSON, CSV string for CSV format) */
+    data: unknown;
+}
+interface RedactPIIStepInput {
+    /** Text to redact PII from */
+    input: string;
+    /** Language code of the input text (e.g. "en") */
+    language: string;
+    /** PII entity types to redact (e.g. ["PHONE_NUMBER", "EMAIL_ADDRESS"]). Empty array means nothing is redacted. */
+    entities: string[];
+    /** Variable name to store the redacted text */
+    destinationVar?: string;
+}
+interface RedactPIIStepOutput {
+    /** The input text with detected PII replaced by entity type placeholders (e.g. "<PHONE_NUMBER>") */
+    text: string;
+}
+interface RemoveBackgroundFromImageStepInput {
+    /** URL of the source image to remove the background from */
+    imageUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar?: string;
+}
+interface RemoveBackgroundFromImageStepOutput {
+    /** CDN URL of the image with background removed (transparent PNG) */
+    imageUrl: string;
+}
+interface ResizeVideoStepInput {
+    /** URL of the source video to resize */
+    videoUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** Resize mode: 'fit' scales within max dimensions, 'exact' forces exact dimensions */
+    mode: "fit" | "exact";
+    /** Maximum width in pixels (used with 'fit' mode) */
+    maxWidth?: number;
+    /** Maximum height in pixels (used with 'fit' mode) */
+    maxHeight?: number;
+    /** Exact width in pixels (used with 'exact' mode) */
+    width?: number;
+    /** Exact height in pixels (used with 'exact' mode) */
+    height?: number;
+    /** Strategy for handling aspect ratio mismatch in 'exact' mode */
+    strategy?: "pad" | "crop";
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface ResizeVideoStepOutput {
+    /** URL of the resized video */
+    videoUrl: string;
+}
+interface RunPackagedWorkflowStepInput {
+    /** The app ID of the packaged workflow source */
+    appId: string;
+    /** The source workflow ID to execute */
+    workflowId: string;
+    /** Variables to pass as input to the packaged workflow */
+    inputVariables: Record<string, unknown>;
+    /** Variables to capture from the packaged workflow output */
+    outputVariables: Record<string, unknown>;
+    /** Display name of the packaged workflow */
+    name: string;
+}
+interface RunPackagedWorkflowStepOutput {
+    /** The result data returned from the packaged workflow */
+    data: unknown;
+}
+interface RunWorkflowStepInput {
+    /** The app ID containing the workflow to run (empty string for same app) */
+    appId: string;
+    /** The name of the workflow to execute */
+    workflowName: string;
+    /** Execution mode: run once, map over an array, or reduce over an array */
+    mode?: "once" | "map" | "reduce";
+    /** Configuration for map/reduce mode execution */
+    mapSettings?: {
+        /** How to interpret the input: default uses AI extraction, stringArray splits by delimiter, array expects JSON */
+        inputMode: "default" | "array" | "stringArray";
+        /** The input string or variable reference to map over */
+        input: string;
+        /** Delimiter for splitting string input in stringArray mode (e.g., comma or newline) */
+        stringArrayDelimiter?: string;
+        /** AI prompt for extracting an array from unstructured input (default inputMode only) */
+        extractPrompt: string;
+        /** Variable name to save the aggregated output results to */
+        outputVariableName: string;
+        /** Whether to run mapped workflows in parallel or sequentially */
+        executionMode: "parallel" | "sequential";
+        /** Behavior when a mapped workflow fails: fail aborts all, ignore continues */
+        errorBehavior: "fail" | "ignore";
+        /** Number of retry attempts for failed workflow executions */
+        numRetries?: number;
+    };
+    /** Variables to pass as input to the child workflow, keyed by variable name */
+    inputVariables?: Record<string, unknown>;
+    /** Variables to capture from the child workflow output, keyed by variable name */
+    outputVariables: Record<string, unknown>;
+}
+interface RunWorkflowStepOutput {
+    /** The result data returned from the spawned workflow(s) */
+    data: unknown;
+}
+interface ScrapeFacebookPageStepInput {
+    /** Full URL to the Facebook page to scrape */
+    pageUrl: string;
+    /** Variable name to store the scraped page data */
+    destinationVar: string;
+}
+interface ScrapeFacebookPageStepOutput {
+    /** The result data returned from the Apify actor run */
+    data: unknown;
+}
+interface ScrapeFacebookPostsStepInput {
+    /** Full URL to the Facebook page to scrape posts from */
+    pageUrl: string;
+    /** Variable name to store the scraped posts data */
+    destinationVar: string;
+}
+interface ScrapeFacebookPostsStepOutput {
+    /** The result data returned from the Apify actor run */
+    data: unknown;
+}
+interface ScrapeInstagramCommentsStepInput {
+    /** Full URL to the Instagram post to scrape comments from */
+    postUrl: string;
+    /** Variable name to store the scraped comments data */
+    destinationVar: string;
+    /** Maximum number of comments to return */
+    resultsLimit: string;
+}
+interface ScrapeInstagramCommentsStepOutput {
+    /** The result data returned from the Apify actor run */
+    data: unknown;
+}
+interface ScrapeInstagramMentionsStepInput {
+    /** Instagram profile URL or username to scrape mentions for */
+    profileUrl: string;
+    /** Variable name to store the scraped mentions data */
+    destinationVar: string;
+    /** Maximum number of mentions to return */
+    resultsLimit: string;
+}
+interface ScrapeInstagramMentionsStepOutput {
+    /** The result data returned from the Apify actor run */
+    data: unknown;
+}
+interface ScrapeInstagramPostsStepInput {
+    /** Instagram profile URL or username to scrape posts from */
+    profileUrl: string;
+    /** Variable name to store the scraped posts data */
+    destinationVar: string;
+    /** Maximum number of posts to return */
+    resultsLimit: string;
+    /** Only return posts newer than this date (ISO 8601 format) */
+    onlyPostsNewerThan: string;
+}
+interface ScrapeInstagramPostsStepOutput {
+    /** The result data returned from the Apify actor run */
+    data: unknown;
+}
+interface ScrapeInstagramProfileStepInput {
+    /** Instagram profile URL or username to scrape */
+    profileUrl: string;
+    /** Variable name to store the scraped profile data */
+    destinationVar: string;
+}
+interface ScrapeInstagramProfileStepOutput {
+    /** The result data returned from the Apify actor run */
+    data: unknown;
+}
+interface ScrapeInstagramReelsStepInput {
+    /** Instagram profile URL or username to scrape reels from */
+    profileUrl: string;
+    /** Variable name to store the scraped reels data */
+    destinationVar: string;
+    /** Maximum number of reels to return */
+    resultsLimit: string;
+}
+interface ScrapeInstagramReelsStepOutput {
+    /** The result data returned from the Apify actor run */
+    data: unknown;
+}
+interface ScrapeLinkedInCompanyStepInput {
+    /** LinkedIn company page URL (e.g. https://www.linkedin.com/company/mindstudioai) */
+    url: string;
+    /** Variable to store the scraped company data */
+    destinationVar?: string;
+}
+interface ScrapeLinkedInCompanyStepOutput {
+    /** Scraped LinkedIn company data */
+    company: unknown;
+}
+interface ScrapeLinkedInProfileStepInput {
+    /** LinkedIn profile URL (e.g. https://www.linkedin.com/in/username) */
+    url: string;
+    /** Variable to store the scraped profile data */
+    destinationVar?: string;
+}
+interface ScrapeLinkedInProfileStepOutput {
+    /** Scraped LinkedIn profile data */
+    profile: unknown;
+}
+interface ScrapeMetaThreadsProfileStepInput {
+    /** Meta Threads profile URL or username to scrape */
+    profileUrl: string;
+    /** Variable name to store the scraped profile data */
+    destinationVar: string;
+}
+interface ScrapeMetaThreadsProfileStepOutput {
+    /** The result data returned from the Apify actor run */
+    data: unknown;
+}
+interface ScrapeUrlStepInput {
+    /** URL(s) to scrape. Accepts a single URL, JSON array, or comma/newline-separated list */
+    url: string;
+    /** Variable name to save the scraped content into */
+    destinationVar?: string;
+    /** Variable name to save the screenshot URL(s) into */
+    screenshotVar?: string;
+    /** Scraping service to use */
+    service: "default" | "firecrawl";
+    /** Whether to enable enhanced scraping for social media URLs (e.g. Twitter, LinkedIn) */
+    autoEnhance: boolean;
+    /** Output format: text returns markdown, html returns raw HTML, json returns structured scraper data */
+    outputFormat: "text" | "json" | "html";
+    /** Page-level scraping options (content filtering, screenshots, headers, etc.) */
+    pageOptions: {
+        /** Whether to extract only the main content of the page, excluding navigation, footers, etc. */
+        onlyMainContent: boolean;
+        /** Whether to capture a screenshot of the page */
+        screenshot: boolean;
+        /** Milliseconds to wait before scraping (0 for immediate) */
+        waitFor: number;
+        /** Whether to convert relative URLs to absolute URLs in the result */
+        replaceAllPathsWithAbsolutePaths: boolean;
+        /** Custom HTTP request headers as key-value pairs */
+        headers: Record<string, unknown>;
+        /** HTML tags to remove from the scraped result */
+        removeTags: string[];
+        /** Whether to scrape using a mobile user-agent */
+        mobile: boolean;
+    };
+}
+interface ScrapeUrlStepOutput {
+    /** Scraped content. Shape depends on outputFormat and number of URLs */
+    content: string | string[] | {
+        /** Markdown/plain-text content of the scraped page */
+        text: string;
+        /** Raw HTML content of the scraped page */
+        html: string;
+        /** Structured data extracted from the page */
+        json?: Record<string, unknown>;
+        /** Screenshot URL of the page (if requested) */
+        screenshotUrl?: string;
+        /** Page metadata (Open Graph / meta tags) */
+        metadata?: {
+            /** Page title */
+            title: string;
+            /** Page meta description */
+            description: string;
+            /** Canonical URL */
+            url: string;
+            /** Open Graph image URL */
+            image: string;
+        };
+    } | {
+        /** Markdown/plain-text content of the scraped page */
+        text: string;
+        /** Raw HTML content of the scraped page */
+        html: string;
+        /** Structured data extracted from the page */
+        json?: Record<string, unknown>;
+        /** Screenshot URL of the page (if requested) */
+        screenshotUrl?: string;
+        /** Page metadata (Open Graph / meta tags) */
+        metadata?: {
+            /** Page title */
+            title: string;
+            /** Page meta description */
+            description: string;
+            /** Canonical URL */
+            url: string;
+            /** Open Graph image URL */
+            image: string;
+        };
+    }[];
+    /** Screenshot URL, only present when screenshot was requested via pageOptions */
+    screenshot?: string;
+}
+interface ScrapeXPostStepInput {
+    /** Full URL to the X post (e.g. https://x.com/elonmusk/status/1655608985058267139) */
+    url: string;
+    /** Variable to store the scraped text content */
+    destinationVar?: string;
+}
+interface ScrapeXPostStepOutput {
+    /** Scraped post data including text, HTML, and optional structured JSON */
+    post: {
+        /** Markdown/plain-text content of the scraped page */
+        text: string;
+        /** Raw HTML content of the scraped page */
+        html: string;
+        /** Structured data extracted from the page */
+        json?: Record<string, unknown>;
+        /** Screenshot URL of the page (if requested) */
+        screenshotUrl?: string;
+        /** Page metadata (Open Graph / meta tags) */
+        metadata?: {
+            /** Page title */
+            title: string;
+            /** Page meta description */
+            description: string;
+            /** Canonical URL */
+            url: string;
+            /** Open Graph image URL */
+            image: string;
+        };
+    };
+}
+interface ScrapeXProfileStepInput {
+    /** Full URL or username for the X profile (e.g. https://x.com/elonmusk) */
+    url: string;
+    /** Variable to store the scraped profile data */
+    destinationVar?: string;
+}
+interface ScrapeXProfileStepOutput {
+    /** Scraped profile data including text, HTML, and optional structured JSON */
+    profile: {
+        /** Markdown/plain-text content of the scraped page */
+        text: string;
+        /** Raw HTML content of the scraped page */
+        html: string;
+        /** Structured data extracted from the page */
+        json?: Record<string, unknown>;
+        /** Screenshot URL of the page (if requested) */
+        screenshotUrl?: string;
+        /** Page metadata (Open Graph / meta tags) */
+        metadata?: {
+            /** Page title */
+            title: string;
+            /** Page meta description */
+            description: string;
+            /** Canonical URL */
+            url: string;
+            /** Open Graph image URL */
+            image: string;
+        };
+    };
+}
+interface SearchGoogleStepInput {
+    /** The search query to send to Google */
+    query: string;
+    /** Variable to store the results in */
+    destinationVar?: string;
+    /** Format for the variable value: "text" or "json" */
+    exportType: "text" | "json";
+    /** Google gl country code (defaults to US) */
+    countryCode?: string;
+    /** Google hl language code (defaults to "en") */
+    languageCode?: string;
+    /** Time range filter: "hour", "day", "week", "month", "year", or "any" */
+    dateRange?: "hour" | "day" | "week" | "month" | "year" | "any";
+    /** Number of results to return (1-100, default: 30) */
+    numResults?: number;
+}
+interface SearchGoogleStepOutput {
+    /** List of search result entries */
+    results: {
+        /** Title of the search result */
+        title: string;
+        /** Snippet/description of the search result */
+        description: string;
+        /** URL of the search result page */
+        url: string;
+    }[];
+}
+interface SearchGoogleImagesStepInput {
+    /** The image search query */
+    query: string;
+    /** Variable to store the results in */
+    destinationVar?: string;
+    /** Format for the variable value: "text" or "json" */
+    exportType: "text" | "json";
+    /** Google gl country code (defaults to US) */
+    countryCode?: string;
+    /** Google hl language code (defaults to "en") */
+    languageCode?: string;
+    /** Time range filter: "hour", "day", "week", "month", "year", or "any" */
+    dateRange?: "hour" | "day" | "week" | "month" | "year" | "any";
+    /** Number of results to return (1-100, default: 30) */
+    numResults?: number;
+}
+interface SearchGoogleImagesStepOutput {
+    /** List of image search results with URLs and metadata */
+    images: {
+        /** Title/alt text of the image */
+        title: string;
+        /** Direct URL of the full-size image */
+        imageUrl: string;
+        /** Width of the full-size image in pixels */
+        imageWidth: number;
+        /** Height of the full-size image in pixels */
+        imageHeight: number;
+        /** URL of the thumbnail image */
+        thumbnailUrl: string;
+        /** Width of the thumbnail in pixels */
+        thumbnailWidth: number;
+        /** Height of the thumbnail in pixels */
+        thumbnailHeight: number;
+        /** Source website name */
+        source: string;
+        /** Domain of the source website */
+        domain: string;
+        /** URL of the page containing the image */
+        link: string;
+        /** Google Images URL for this result */
+        googleUrl: string;
+        /** Position/rank of this result in the search results */
+        position: number;
+    }[];
+}
+interface SearchGoogleNewsStepInput {
+    /** The news search query */
+    text: string;
+    /** Variable to store the results in */
+    destinationVar?: string;
+    /** Format for the variable value: "text" or "json" */
+    exportType: "text" | "json";
+    /** Number of results to return (1-100, default: 30) */
+    numResults?: number;
+}
+interface SearchGoogleNewsStepOutput {
+    /** List of matching news articles */
+    articles: {
+        /** Headline of the news article */
+        title: string;
+        /** URL to the full article */
+        link: string;
+        /** Publication date of the article */
+        date: string;
+        /** Source publication */
+        source: {
+            /** Name of the news source */
+            name: string;
+        };
+        /** Brief excerpt or summary of the article */
+        snippet?: string;
+    }[];
+}
+interface SearchGoogleTrendsStepInput {
+    /** The search term to look up on Google Trends */
+    text: string;
+    /** Variable to store the results in */
+    destinationVar?: string;
+    /** Language code (e.g. "en") */
+    hl: string;
+    /** Geographic region: empty string for worldwide, or a two-letter country code */
+    geo: string;
+    /** Type of trend data to return */
+    data_type: "TIMESERIES" | "GEO_MAP" | "GEO_MAP_0" | "RELATED_TOPICS" | "RELATED_QUERIES";
+    /** Category filter ("0" for all categories) */
+    cat: string;
+    /** Date range for trend data. Available options:   - "now 1-H" - Past hour   - "now 4-H" - Past 4 hours   - "now 1-d" - Past day   - "now 7-d" - Past 7 days   - "today 1-m" - Past 30 days   - "today 3-m" - Past 90 days   - "today 12-m" - Past 12 months   - "today 5-y" - Past 5 years   - "all - 2004" - present   - You can also pass custom values: "yyyy-mm-dd yyyy-mm-dd" */
+    date: string;
+    /** Timezone offset in minutes (-1439 to 1439, default: 420 for PDT) */
+    ts: string;
+}
+interface SearchGoogleTrendsStepOutput {
+    /** Google Trends data for the searched term */
+    trends: Record<string, unknown>;
+}
+interface SearchPerplexityStepInput {
+    /** Search query to send to Perplexity */
+    query: string;
+    /** Variable name to store the search results */
+    destinationVar?: string;
+    /** Output format for the variable: plain text or structured JSON */
+    exportType: "text" | "json";
+    /** ISO country code to filter results by region (e.g. "us", "gb") */
+    countryCode?: string;
+    /** Number of results to return (1-20, default: 10) */
+    numResults?: number;
+}
+interface SearchPerplexityStepOutput {
+    /** List of structured search results */
+    results: {
+        /** Page title of the search result */
+        title: string;
+        /** Snippet or description of the search result */
+        description: string;
+        /** URL of the search result page */
+        url: string;
+    }[];
+}
+interface SearchXPostsStepInput {
+    /** Search query (max 512 chars, supports X API v2 search operators) */
+    query: string;
+    /** Variable to store the JSON-stringified results */
+    destinationVar?: string;
+    /** Search scope: "recent" for past 7 days or "all" for full archive */
+    scope: "recent" | "all";
+    /** Additional search options */
+    options: {
+        /** ISO 8601 date; only return posts after this time */
+        startTime?: string;
+        /** ISO 8601 date; only return posts before this time */
+        endTime?: string;
+        /** Number of results to return (default: 50, max: 100) */
+        maxResults?: number;
+    };
+}
+interface SearchXPostsStepOutput {
+    /** List of matching X posts */
+    posts: {
+        /** Unique post identifier */
+        id: string;
+        /** Author's X user ID */
+        authorId: string;
+        /** ISO 8601 timestamp when the post was created */
+        dateCreated: string;
+        /** Text content of the post */
+        text: string;
+        /** Engagement statistics for the post */
+        stats: {
+            /** Number of retweets/reposts */
+            retweets: number;
+            /** Number of replies */
+            replies: number;
+            /** Number of likes */
+            likes: number;
+        };
+    }[];
+}
+interface SearchYoutubeStepInput {
+    /** Search query for YouTube videos */
+    query: string;
+    /** Variable name to save the search results */
+    destinationVar?: string;
+    /** Maximum number of pages to fetch (1-5) */
+    limitPages: string;
+    /** YouTube search parameter (sp) filter value */
+    filter: string;
+    /** Filter type identifier */
+    filterType: string;
+    /** Google gl country code for regional results (default: "US") */
+    countryCode?: string;
+    /** Google hl language code for result language (default: "en") */
+    languageCode?: string;
+}
+interface SearchYoutubeStepOutput {
+    /** YouTube search results including video_results, channel_results, etc. */
+    results: Record<string, unknown>;
+}
+interface SearchYoutubeTrendsStepInput {
+    /** Variable name to save the trends data */
+    destinationVar?: string;
+    /** Trending category: "now" (trending now), "music", "gaming", or "films" */
+    bp: "now" | "music" | "gaming" | "films";
+    /** Language code (e.g. "en") */
+    hl: string;
+    /** Country code (e.g. "US") */
+    gl: string;
+}
+interface SearchYoutubeTrendsStepOutput {
+    /** Trending video data for the selected category and region */
+    trends: Record<string, unknown>;
+}
+interface SendEmailStepInput {
+    /** Email subject line */
+    subject: string;
+    /** Email body content (plain text, markdown, HTML, or a CDN URL to an HTML file) */
+    body: string;
+    /** OAuth connection ID(s) for the recipient(s), comma-separated for multiple */
+    connectionId: string;
+    /** When true, auto-convert the body text into a styled HTML email using AI */
+    generateHtml?: boolean;
+    /** Natural language instructions for the HTML generation style */
+    generateHtmlInstructions?: string;
+    /** Model settings override for HTML generation */
+    generateHtmlModelOverride?: {
+        /** Model identifier (e.g. "gpt-4", "claude-3-opus") */
+        model: string;
+        /** Sampling temperature for the model (0-2) */
+        temperature: number;
+        /** Maximum number of tokens in the model's response */
+        maxResponseTokens: number;
+        /** Whether to skip the system preamble/instructions */
+        ignorePreamble?: boolean;
+        /** Preprocessor applied to user messages before sending to the model */
+        userMessagePreprocessor?: {
+            /** Data source identifier for the preprocessor */
+            dataSource?: string;
+            /** Template string applied to user messages before sending to the model */
+            messageTemplate?: string;
+            /** Maximum number of results to include from the data source */
+            maxResults?: number;
+            /** Whether the preprocessor is active */
+            enabled?: boolean;
+            /** Whether child steps should inherit this preprocessor configuration */
+            shouldInherit?: boolean;
+        };
+        /** System preamble/instructions for the model */
+        preamble?: string;
+        /** Whether multi-model candidate generation is enabled */
+        multiModelEnabled?: boolean;
+        /** Whether the user can edit the model's response */
+        editResponseEnabled?: boolean;
+        /** Additional model-specific configuration */
+        config?: Record<string, unknown>;
+    };
+    /** URLs of files to attach to the email */
+    attachments?: string[];
+}
+interface SendEmailStepOutput {
+    /** Email addresses the message was sent to */
+    recipients: string[];
+}
+interface SendSMSStepInput {
+    /** SMS message body text */
+    body: string;
+    /** OAuth connection ID for the recipient phone number */
+    connectionId: string;
+}
+type SendSMSStepOutput = unknown;
+interface SetRunTitleStepInput {
+    /** The title to assign to the agent run (supports variable interpolation) */
+    title: string;
+}
+type SetRunTitleStepOutput = unknown;
+interface SetVariableStepInput {
+    /** Variable name to set (supports dynamic names via variable interpolation) */
+    destinationVariableName: string;
+    /** Value to assign (string or array of strings, supports variable interpolation) */
+    value: string | string[];
+    /** UI input type hint controlling the editor widget */
+    type: "imageUrl" | "videoUrl" | "fileUrl" | "plaintext" | "textArray" | "imageUrlArray" | "videoUrlArray";
+}
+interface SetVariableStepOutput {
+    /** The resolved variable name that was set */
+    variableName: string;
+    /** The resolved value that was assigned */
+    value: string | string[];
+}
+interface TelegramSendAudioStepInput {
+    /** Telegram bot token in "botId:token" format */
+    botToken: string;
+    /** Telegram chat ID to send the audio to */
+    chatId: string;
+    /** URL of the audio file to send */
+    audioUrl: string;
+    /** Send as a standard audio track ("audio") or as a voice note ("voice") */
+    mode: "audio" | "voice";
+    /** Optional caption text for the audio */
+    caption?: string;
+}
+type TelegramSendAudioStepOutput = unknown;
+interface TelegramSendFileStepInput {
+    /** Telegram bot token in "botId:token" format */
+    botToken: string;
+    /** Telegram chat ID to send the file to */
+    chatId: string;
+    /** URL of the document/file to send */
+    fileUrl: string;
+    /** Optional caption text for the file */
+    caption?: string;
+}
+type TelegramSendFileStepOutput = unknown;
+interface TelegramSendImageStepInput {
+    /** Telegram bot token in "botId:token" format */
+    botToken: string;
+    /** Telegram chat ID to send the image to */
+    chatId: string;
+    /** URL of the image to send */
+    imageUrl: string;
+    /** Optional caption text for the image */
+    caption?: string;
+}
+type TelegramSendImageStepOutput = unknown;
+interface TelegramSendMessageStepInput {
+    /** Telegram bot token in "botId:token" format */
+    botToken: string;
+    /** Telegram chat ID to send the message to */
+    chatId: string;
+    /** Message text to send (MarkdownV2 formatting supported) */
+    text: string;
+}
+type TelegramSendMessageStepOutput = unknown;
+interface TelegramSendVideoStepInput {
+    /** Telegram bot token in "botId:token" format */
+    botToken: string;
+    /** Telegram chat ID to send the video to */
+    chatId: string;
+    /** URL of the video to send */
+    videoUrl: string;
+    /** Optional caption text for the video */
+    caption?: string;
+}
+type TelegramSendVideoStepOutput = unknown;
+interface TelegramSetTypingStepInput {
+    /** Telegram bot token in "botId:token" format */
+    botToken: string;
+    /** Telegram chat ID to show the typing indicator in */
+    chatId: string;
+}
+type TelegramSetTypingStepOutput = unknown;
+interface TextToSpeechStepInput {
+    /** The text to convert to speech */
+    text: string;
+    /** foreground = display audio to user, background = save URL to variable */
+    mode: "foreground" | "background";
+    /** Variable name to save the audio URL into (used in background mode) */
+    destinationVar?: string;
+    skipAssetCreation?: boolean;
+    /** Optional model configuration override. Uses the workflow's default speech model if not specified */
+    speechModelOverride?: {
+        /** Speech synthesis model identifier */
+        model: string;
+        /** Additional model-specific configuration */
+        config?: Record<string, unknown>;
+    };
+}
+interface TextToSpeechStepOutput {
+    /** URL of the generated audio file */
+    audioUrl: string;
+}
+interface TranscribeAudioStepInput {
+    /** URL of the audio file to transcribe */
+    audioUrl: string;
+    /** Optional context to improve transcription accuracy (e.g. language, speaker names, domain terms) */
+    prompt: string;
+    /** Variable name to save the transcribed text into */
+    destinationVar?: string;
+    /** Optional model configuration override. Uses the workflow's default transcription model if not specified */
+    transcriptionModelOverride?: {
+        /** Audio transcription model identifier */
+        model: string;
+        /** Additional model-specific configuration */
+        config?: Record<string, unknown>;
+    };
+}
+interface TranscribeAudioStepOutput {
+    /** The transcribed text from the audio file */
+    text: string;
+}
+interface TrimMediaStepInput {
+    /** URL of the source audio or video file to trim */
+    inputUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** Start position in seconds for the trim */
+    start?: number | string;
+    /** Duration of the trimmed segment in seconds. Omit to trim to the end of the clip. */
+    duration?: string | number;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface TrimMediaStepOutput {
+    /** URL of the trimmed media file */
+    mediaUrl: string;
+}
+interface UpdateGoogleCalendarEventStepInput {
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** Google Calendar event ID to update */
+    eventId: string;
+    /** Updated event title */
+    summary?: string;
+    /** Updated event description */
+    description?: string;
+    /** Updated event location */
+    location?: string;
+    /** Updated start time in ISO 8601 format */
+    startDateTime?: string;
+    /** Updated end time in ISO 8601 format */
+    endDateTime?: string;
+    /** Updated attendee email addresses (one per line, replaces all existing attendees) */
+    attendees?: string;
+    /** Variable to store the result (JSON with eventId and htmlLink) */
+    destinationVar?: string;
+    /** Calendar ID (defaults to "primary" if omitted) */
+    calendarId?: string;
+}
+interface UpdateGoogleCalendarEventStepOutput {
+    /** Google Calendar event ID */
+    eventId: string;
+    /** URL to view the updated event in Google Calendar */
+    htmlLink: string;
+}
+interface UpdateGoogleDocStepInput {
+    /** Google Document ID to update */
+    documentId: string;
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** New content to write to the document */
+    text: string;
+    /** Format of the text field: "plain", "html", or "markdown" */
+    textType: "plain" | "html" | "markdown";
+    /** How to apply the content: "addToTop", "addToBottom", or "overwrite" */
+    operationType: "addToTop" | "addToBottom" | "overwrite";
+}
+interface UpdateGoogleDocStepOutput {
+    /** URL of the updated Google Document */
+    documentUrl: string;
+}
+interface UpdateGoogleSheetStepInput {
+    /** CSV data to write to the spreadsheet */
+    text: string;
+    /** Google OAuth connection ID */
+    connectionId: string;
+    /** Google Spreadsheet ID to update */
+    spreadsheetId: string;
+    /** Target cell range in A1 notation (used with "range" operationType) */
+    range: string;
+    /** How to apply the data: "addToBottom", "overwrite", or "range" */
+    operationType: "addToBottom" | "overwrite" | "range";
+}
+interface UpdateGoogleSheetStepOutput {
+    /** URL of the updated Google Spreadsheet */
+    spreadsheetUrl: string;
+}
+interface UpscaleImageStepInput {
+    /** URL of the image to upscale */
+    imageUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar?: string;
+    /** Target output resolution */
+    targetResolution: "2k" | "4k" | "8k";
+    /** Upscaling engine quality tier */
+    engine: "standard" | "pro";
+}
+interface UpscaleImageStepOutput {
+    /** CDN URL of the upscaled image (PNG) */
+    imageUrl: string;
+}
+interface UpscaleVideoStepInput {
+    /** URL of the source video to upscale */
+    videoUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** Target output resolution for the upscaled video */
+    targetResolution: "720p" | "1080p" | "2K" | "4K";
+    /** Upscaling engine to use. Higher tiers produce better quality at higher cost. */
+    engine: "standard" | "pro" | "ultimate" | "flashvsr" | "seedance" | "seedvr2" | "runwayml/upscale-v1";
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface UpscaleVideoStepOutput {
+    /** URL of the upscaled video */
+    videoUrl: string;
+}
+interface UserMessageStepInput {
+    /** The message to send (prompt for AI, or text for system echo) */
+    message: string;
+    /** Output behavior: background saves to variable, foreground streams to user. In direct execution, this is ignored and all requests are "background" */
+    mode?: "foreground" | "background";
+    /** Message source: "user" sends to AI model, "system" echoes message content directly */
+    source: "user" | "system";
+    /** Variable name to save the response to */
+    destinationVar?: string | null;
+    /** Model configuration override. Optional; uses the workflow's default model if not specified */
+    modelOverride?: {
+        /** Model identifier (e.g. "gpt-4", "claude-3-opus") */
+        model: string;
+        /** Sampling temperature for the model (0-2) */
+        temperature: number;
+        /** Maximum number of tokens in the model's response */
+        maxResponseTokens: number;
+        /** Whether to skip the system preamble/instructions */
+        ignorePreamble?: boolean;
+        /** Preprocessor applied to user messages before sending to the model */
+        userMessagePreprocessor?: {
+            /** Data source identifier for the preprocessor */
+            dataSource?: string;
+            /** Template string applied to user messages before sending to the model */
+            messageTemplate?: string;
+            /** Maximum number of results to include from the data source */
+            maxResults?: number;
+            /** Whether the preprocessor is active */
+            enabled?: boolean;
+            /** Whether child steps should inherit this preprocessor configuration */
+            shouldInherit?: boolean;
+        };
+        /** System preamble/instructions for the model */
+        preamble?: string;
+        /** Whether multi-model candidate generation is enabled */
+        multiModelEnabled?: boolean;
+        /** Whether the user can edit the model's response */
+        editResponseEnabled?: boolean;
+        /** Additional model-specific configuration */
+        config?: Record<string, unknown>;
+    };
+    /** Output format constraint for structured responses */
+    structuredOutputType?: "text" | "json" | "csv";
+    /** Sample showing the desired output shape (for JSON/CSV formats). A TypeScript interface is also useful here for more complex types. */
+    structuredOutputExample?: string;
+    /** Media display type for foreground system messages. This must be used with mode=foreground and the content of the message must only be a URL to the media asset. */
+    systemDisplayType?: "message" | "pdf" | "csv" | "image" | "html" | "video" | "xlsx" | "docx";
+    /** Whether to include or exclude prior chat history in the AI context */
+    chatHistoryMode?: "include" | "exclude";
+    /** Transition control mode. Leave unset. */
+    transitionControl?: "default" | "native";
+    /** Share button visibility control */
+    shareControl?: "default" | "hidden";
+}
+interface UserMessageStepOutput {
+    /** The AI model's response or echoed system message content */
+    content: string;
+}
+interface VideoFaceSwapStepInput {
+    /** URL of the source video containing faces to swap */
+    videoUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** URL of the image containing the replacement face */
+    faceImageUrl: string;
+    /** Zero-based index of the face to replace in the video */
+    targetIndex: number;
+    /** Face swap engine to use */
+    engine: string;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface VideoFaceSwapStepOutput {
+    /** URL of the face-swapped video */
+    videoUrl: string;
+}
+interface VideoRemoveBackgroundStepInput {
+    /** URL of the source video */
+    videoUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** Whether to make the background transparent or replace it with an image */
+    newBackground: "transparent" | "image";
+    /** URL of a replacement background image. Required when newBackground is 'image'. */
+    newBackgroundImageUrl?: string;
+    /** Background removal engine to use */
+    engine: string;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface VideoRemoveBackgroundStepOutput {
+    /** URL of the video with background removed or replaced */
+    videoUrl: string;
+}
+interface VideoRemoveWatermarkStepInput {
+    /** URL of the source video containing a watermark */
+    videoUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** Watermark removal engine to use */
+    engine: string;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface VideoRemoveWatermarkStepOutput {
+    /** URL of the video with watermark removed */
+    videoUrl: string;
+}
+interface WatermarkImageStepInput {
+    /** URL of the base image */
+    imageUrl: string;
+    /** URL of the watermark image to overlay */
+    watermarkImageUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar?: string;
+    /** Corner position for the watermark placement */
+    corner: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    /** Padding from the corner in pixels */
+    paddingPx: number;
+    /** Width of the watermark overlay in pixels */
+    widthPx: number;
+    /** When true, the result will not appear in the user's asset history */
+    skipAssetCreation?: boolean;
+}
+interface WatermarkImageStepOutput {
+    /** CDN URL of the watermarked image */
+    imageUrl: string;
+}
+interface WatermarkVideoStepInput {
+    /** URL of the source video */
+    videoUrl: string;
+    /** URL of the watermark image to overlay */
+    imageUrl: string;
+    /** Variable name to store the output URL */
+    destinationVar: string;
+    /** Corner position for the watermark placement */
+    corner: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    /** Padding from the corner in pixels */
+    paddingPx: number;
+    /** Width of the watermark overlay in pixels */
+    widthPx: number;
+    /** When true, the result will not appear in the user's asset history. Useful for intermediate compositing steps. */
+    skipAssetCreation?: boolean;
+}
+interface WatermarkVideoStepOutput {
+    /** URL of the watermarked video */
+    videoUrl: string;
+}
+/** Union of all available step type names. */
+type StepName = "activeCampaignAddNote" | "activeCampaignCreateContact" | "addSubtitlesToVideo" | "airtableCreateUpdateRecord" | "airtableDeleteRecord" | "airtableGetRecord" | "airtableGetTableRecords" | "analyzeImage" | "analyzeVideo" | "captureThumbnail" | "codaCreateUpdatePage" | "codaCreateUpdateRow" | "codaFindRow" | "codaGetPage" | "codaGetTableRows" | "convertPdfToImages" | "createGoogleCalendarEvent" | "createGoogleDoc" | "createGoogleSheet" | "deleteGoogleCalendarEvent" | "detectPII" | "downloadVideo" | "enhanceImageGenerationPrompt" | "enhanceVideoGenerationPrompt" | "enrichPerson" | "extractAudioFromVideo" | "extractText" | "fetchGoogleDoc" | "fetchGoogleSheet" | "fetchSlackChannelHistory" | "fetchYoutubeCaptions" | "fetchYoutubeChannel" | "fetchYoutubeComments" | "fetchYoutubeVideo" | "generateChart" | "generateImage" | "generateLipsync" | "generateMusic" | "generatePdf" | "generateStaticVideoFromImage" | "generateVideo" | "getGoogleCalendarEvent" | "getMediaMetadata" | "httpRequest" | "hubspotCreateCompany" | "hubspotCreateContact" | "hubspotGetCompany" | "hubspotGetContact" | "hunterApiCompanyEnrichment" | "hunterApiDomainSearch" | "hunterApiEmailFinder" | "hunterApiEmailVerification" | "hunterApiPersonEnrichment" | "imageFaceSwap" | "imageRemoveWatermark" | "insertVideoClips" | "listGoogleCalendarEvents" | "logic" | "makeDotComRunScenario" | "mergeAudio" | "mergeVideos" | "mixAudioIntoVideo" | "muteVideo" | "n8nRunNode" | "notionCreatePage" | "notionUpdatePage" | "peopleSearch" | "postToLinkedIn" | "postToSlackChannel" | "postToX" | "postToZapier" | "queryDataSource" | "queryExternalDatabase" | "redactPII" | "removeBackgroundFromImage" | "resizeVideo" | "runPackagedWorkflow" | "runWorkflow" | "scrapeFacebookPage" | "scrapeFacebookPosts" | "scrapeInstagramComments" | "scrapeInstagramMentions" | "scrapeInstagramPosts" | "scrapeInstagramProfile" | "scrapeInstagramReels" | "scrapeLinkedInCompany" | "scrapeLinkedInProfile" | "scrapeMetaThreadsProfile" | "scrapeUrl" | "scrapeXPost" | "scrapeXProfile" | "searchGoogle" | "searchGoogleImages" | "searchGoogleNews" | "searchGoogleTrends" | "searchPerplexity" | "searchXPosts" | "searchYoutube" | "searchYoutubeTrends" | "sendEmail" | "sendSMS" | "setRunTitle" | "setVariable" | "telegramSendAudio" | "telegramSendFile" | "telegramSendImage" | "telegramSendMessage" | "telegramSendVideo" | "telegramSetTyping" | "textToSpeech" | "transcribeAudio" | "trimMedia" | "updateGoogleCalendarEvent" | "updateGoogleDoc" | "updateGoogleSheet" | "upscaleImage" | "upscaleVideo" | "userMessage" | "videoFaceSwap" | "videoRemoveBackground" | "videoRemoveWatermark" | "watermarkImage" | "watermarkVideo";
+/** Maps step names to their input types. */
+interface StepInputMap {
+    activeCampaignAddNote: ActiveCampaignAddNoteStepInput;
+    activeCampaignCreateContact: ActiveCampaignCreateContactStepInput;
+    addSubtitlesToVideo: AddSubtitlesToVideoStepInput;
+    airtableCreateUpdateRecord: AirtableCreateUpdateRecordStepInput;
+    airtableDeleteRecord: AirtableDeleteRecordStepInput;
+    airtableGetRecord: AirtableGetRecordStepInput;
+    airtableGetTableRecords: AirtableGetTableRecordsStepInput;
+    analyzeImage: AnalyzeImageStepInput;
+    analyzeVideo: AnalyzeVideoStepInput;
+    captureThumbnail: CaptureThumbnailStepInput;
+    codaCreateUpdatePage: CodaCreateUpdatePageStepInput;
+    codaCreateUpdateRow: CodaCreateUpdateRowStepInput;
+    codaFindRow: CodaFindRowStepInput;
+    codaGetPage: CodaGetPageStepInput;
+    codaGetTableRows: CodaGetTableRowsStepInput;
+    convertPdfToImages: ConvertPdfToImagesStepInput;
+    createGoogleCalendarEvent: CreateGoogleCalendarEventStepInput;
+    createGoogleDoc: CreateGoogleDocStepInput;
+    createGoogleSheet: CreateGoogleSheetStepInput;
+    deleteGoogleCalendarEvent: DeleteGoogleCalendarEventStepInput;
+    detectPII: DetectPIIStepInput;
+    downloadVideo: DownloadVideoStepInput;
+    enhanceImageGenerationPrompt: EnhanceImageGenerationPromptStepInput;
+    enhanceVideoGenerationPrompt: EnhanceVideoGenerationPromptStepInput;
+    enrichPerson: EnrichPersonStepInput;
+    extractAudioFromVideo: ExtractAudioFromVideoStepInput;
+    extractText: ExtractTextStepInput;
+    fetchGoogleDoc: FetchGoogleDocStepInput;
+    fetchGoogleSheet: FetchGoogleSheetStepInput;
+    fetchSlackChannelHistory: FetchSlackChannelHistoryStepInput;
+    fetchYoutubeCaptions: FetchYoutubeCaptionsStepInput;
+    fetchYoutubeChannel: FetchYoutubeChannelStepInput;
+    fetchYoutubeComments: FetchYoutubeCommentsStepInput;
+    fetchYoutubeVideo: FetchYoutubeVideoStepInput;
+    generateChart: GenerateChartStepInput;
+    generateImage: GenerateImageStepInput;
+    generateLipsync: GenerateLipsyncStepInput;
+    generateMusic: GenerateMusicStepInput;
+    generatePdf: GeneratePdfStepInput;
+    generateStaticVideoFromImage: GenerateStaticVideoFromImageStepInput;
+    generateVideo: GenerateVideoStepInput;
+    getGoogleCalendarEvent: GetGoogleCalendarEventStepInput;
+    getMediaMetadata: GetMediaMetadataStepInput;
+    httpRequest: HttpRequestStepInput;
+    hubspotCreateCompany: HubspotCreateCompanyStepInput;
+    hubspotCreateContact: HubspotCreateContactStepInput;
+    hubspotGetCompany: HubspotGetCompanyStepInput;
+    hubspotGetContact: HubspotGetContactStepInput;
+    hunterApiCompanyEnrichment: HunterApiCompanyEnrichmentStepInput;
+    hunterApiDomainSearch: HunterApiDomainSearchStepInput;
+    hunterApiEmailFinder: HunterApiEmailFinderStepInput;
+    hunterApiEmailVerification: HunterApiEmailVerificationStepInput;
+    hunterApiPersonEnrichment: HunterApiPersonEnrichmentStepInput;
+    imageFaceSwap: ImageFaceSwapStepInput;
+    imageRemoveWatermark: ImageRemoveWatermarkStepInput;
+    insertVideoClips: InsertVideoClipsStepInput;
+    listGoogleCalendarEvents: ListGoogleCalendarEventsStepInput;
+    logic: LogicStepInput;
+    makeDotComRunScenario: MakeDotComRunScenarioStepInput;
+    mergeAudio: MergeAudioStepInput;
+    mergeVideos: MergeVideosStepInput;
+    mixAudioIntoVideo: MixAudioIntoVideoStepInput;
+    muteVideo: MuteVideoStepInput;
+    n8nRunNode: N8nRunNodeStepInput;
+    notionCreatePage: NotionCreatePageStepInput;
+    notionUpdatePage: NotionUpdatePageStepInput;
+    peopleSearch: PeopleSearchStepInput;
+    postToLinkedIn: PostToLinkedInStepInput;
+    postToSlackChannel: PostToSlackChannelStepInput;
+    postToX: PostToXStepInput;
+    postToZapier: PostToZapierStepInput;
+    queryDataSource: QueryDataSourceStepInput;
+    queryExternalDatabase: QueryExternalDatabaseStepInput;
+    redactPII: RedactPIIStepInput;
+    removeBackgroundFromImage: RemoveBackgroundFromImageStepInput;
+    resizeVideo: ResizeVideoStepInput;
+    runPackagedWorkflow: RunPackagedWorkflowStepInput;
+    runWorkflow: RunWorkflowStepInput;
+    scrapeFacebookPage: ScrapeFacebookPageStepInput;
+    scrapeFacebookPosts: ScrapeFacebookPostsStepInput;
+    scrapeInstagramComments: ScrapeInstagramCommentsStepInput;
+    scrapeInstagramMentions: ScrapeInstagramMentionsStepInput;
+    scrapeInstagramPosts: ScrapeInstagramPostsStepInput;
+    scrapeInstagramProfile: ScrapeInstagramProfileStepInput;
+    scrapeInstagramReels: ScrapeInstagramReelsStepInput;
+    scrapeLinkedInCompany: ScrapeLinkedInCompanyStepInput;
+    scrapeLinkedInProfile: ScrapeLinkedInProfileStepInput;
+    scrapeMetaThreadsProfile: ScrapeMetaThreadsProfileStepInput;
+    scrapeUrl: ScrapeUrlStepInput;
+    scrapeXPost: ScrapeXPostStepInput;
+    scrapeXProfile: ScrapeXProfileStepInput;
+    searchGoogle: SearchGoogleStepInput;
+    searchGoogleImages: SearchGoogleImagesStepInput;
+    searchGoogleNews: SearchGoogleNewsStepInput;
+    searchGoogleTrends: SearchGoogleTrendsStepInput;
+    searchPerplexity: SearchPerplexityStepInput;
+    searchXPosts: SearchXPostsStepInput;
+    searchYoutube: SearchYoutubeStepInput;
+    searchYoutubeTrends: SearchYoutubeTrendsStepInput;
+    sendEmail: SendEmailStepInput;
+    sendSMS: SendSMSStepInput;
+    setRunTitle: SetRunTitleStepInput;
+    setVariable: SetVariableStepInput;
+    telegramSendAudio: TelegramSendAudioStepInput;
+    telegramSendFile: TelegramSendFileStepInput;
+    telegramSendImage: TelegramSendImageStepInput;
+    telegramSendMessage: TelegramSendMessageStepInput;
+    telegramSendVideo: TelegramSendVideoStepInput;
+    telegramSetTyping: TelegramSetTypingStepInput;
+    textToSpeech: TextToSpeechStepInput;
+    transcribeAudio: TranscribeAudioStepInput;
+    trimMedia: TrimMediaStepInput;
+    updateGoogleCalendarEvent: UpdateGoogleCalendarEventStepInput;
+    updateGoogleDoc: UpdateGoogleDocStepInput;
+    updateGoogleSheet: UpdateGoogleSheetStepInput;
+    upscaleImage: UpscaleImageStepInput;
+    upscaleVideo: UpscaleVideoStepInput;
+    userMessage: UserMessageStepInput;
+    videoFaceSwap: VideoFaceSwapStepInput;
+    videoRemoveBackground: VideoRemoveBackgroundStepInput;
+    videoRemoveWatermark: VideoRemoveWatermarkStepInput;
+    watermarkImage: WatermarkImageStepInput;
+    watermarkVideo: WatermarkVideoStepInput;
+}
+/** Maps step names to their output types. */
+interface StepOutputMap {
+    activeCampaignAddNote: ActiveCampaignAddNoteStepOutput;
+    activeCampaignCreateContact: ActiveCampaignCreateContactStepOutput;
+    addSubtitlesToVideo: AddSubtitlesToVideoStepOutput;
+    airtableCreateUpdateRecord: AirtableCreateUpdateRecordStepOutput;
+    airtableDeleteRecord: AirtableDeleteRecordStepOutput;
+    airtableGetRecord: AirtableGetRecordStepOutput;
+    airtableGetTableRecords: AirtableGetTableRecordsStepOutput;
+    analyzeImage: AnalyzeImageStepOutput;
+    analyzeVideo: AnalyzeVideoStepOutput;
+    captureThumbnail: CaptureThumbnailStepOutput;
+    codaCreateUpdatePage: CodaCreateUpdatePageStepOutput;
+    codaCreateUpdateRow: CodaCreateUpdateRowStepOutput;
+    codaFindRow: CodaFindRowStepOutput;
+    codaGetPage: CodaGetPageStepOutput;
+    codaGetTableRows: CodaGetTableRowsStepOutput;
+    convertPdfToImages: ConvertPdfToImagesStepOutput;
+    createGoogleCalendarEvent: CreateGoogleCalendarEventStepOutput;
+    createGoogleDoc: CreateGoogleDocStepOutput;
+    createGoogleSheet: CreateGoogleSheetStepOutput;
+    deleteGoogleCalendarEvent: DeleteGoogleCalendarEventStepOutput;
+    detectPII: DetectPIIStepOutput;
+    downloadVideo: DownloadVideoStepOutput;
+    enhanceImageGenerationPrompt: EnhanceImageGenerationPromptStepOutput;
+    enhanceVideoGenerationPrompt: EnhanceVideoGenerationPromptStepOutput;
+    enrichPerson: EnrichPersonStepOutput;
+    extractAudioFromVideo: ExtractAudioFromVideoStepOutput;
+    extractText: ExtractTextStepOutput;
+    fetchGoogleDoc: FetchGoogleDocStepOutput;
+    fetchGoogleSheet: FetchGoogleSheetStepOutput;
+    fetchSlackChannelHistory: FetchSlackChannelHistoryStepOutput;
+    fetchYoutubeCaptions: FetchYoutubeCaptionsStepOutput;
+    fetchYoutubeChannel: FetchYoutubeChannelStepOutput;
+    fetchYoutubeComments: FetchYoutubeCommentsStepOutput;
+    fetchYoutubeVideo: FetchYoutubeVideoStepOutput;
+    generateChart: GenerateChartStepOutput;
+    generateImage: GenerateImageStepOutput;
+    generateLipsync: GenerateLipsyncStepOutput;
+    generateMusic: GenerateMusicStepOutput;
+    generatePdf: GeneratePdfStepOutput;
+    generateStaticVideoFromImage: GenerateStaticVideoFromImageStepOutput;
+    generateVideo: GenerateVideoStepOutput;
+    getGoogleCalendarEvent: GetGoogleCalendarEventStepOutput;
+    getMediaMetadata: GetMediaMetadataStepOutput;
+    httpRequest: HttpRequestStepOutput;
+    hubspotCreateCompany: HubspotCreateCompanyStepOutput;
+    hubspotCreateContact: HubspotCreateContactStepOutput;
+    hubspotGetCompany: HubspotGetCompanyStepOutput;
+    hubspotGetContact: HubspotGetContactStepOutput;
+    hunterApiCompanyEnrichment: HunterApiCompanyEnrichmentStepOutput;
+    hunterApiDomainSearch: HunterApiDomainSearchStepOutput;
+    hunterApiEmailFinder: HunterApiEmailFinderStepOutput;
+    hunterApiEmailVerification: HunterApiEmailVerificationStepOutput;
+    hunterApiPersonEnrichment: HunterApiPersonEnrichmentStepOutput;
+    imageFaceSwap: ImageFaceSwapStepOutput;
+    imageRemoveWatermark: ImageRemoveWatermarkStepOutput;
+    insertVideoClips: InsertVideoClipsStepOutput;
+    listGoogleCalendarEvents: ListGoogleCalendarEventsStepOutput;
+    logic: LogicStepOutput;
+    makeDotComRunScenario: MakeDotComRunScenarioStepOutput;
+    mergeAudio: MergeAudioStepOutput;
+    mergeVideos: MergeVideosStepOutput;
+    mixAudioIntoVideo: MixAudioIntoVideoStepOutput;
+    muteVideo: MuteVideoStepOutput;
+    n8nRunNode: N8nRunNodeStepOutput;
+    notionCreatePage: NotionCreatePageStepOutput;
+    notionUpdatePage: NotionUpdatePageStepOutput;
+    peopleSearch: PeopleSearchStepOutput;
+    postToLinkedIn: PostToLinkedInStepOutput;
+    postToSlackChannel: PostToSlackChannelStepOutput;
+    postToX: PostToXStepOutput;
+    postToZapier: PostToZapierStepOutput;
+    queryDataSource: QueryDataSourceStepOutput;
+    queryExternalDatabase: QueryExternalDatabaseStepOutput;
+    redactPII: RedactPIIStepOutput;
+    removeBackgroundFromImage: RemoveBackgroundFromImageStepOutput;
+    resizeVideo: ResizeVideoStepOutput;
+    runPackagedWorkflow: RunPackagedWorkflowStepOutput;
+    runWorkflow: RunWorkflowStepOutput;
+    scrapeFacebookPage: ScrapeFacebookPageStepOutput;
+    scrapeFacebookPosts: ScrapeFacebookPostsStepOutput;
+    scrapeInstagramComments: ScrapeInstagramCommentsStepOutput;
+    scrapeInstagramMentions: ScrapeInstagramMentionsStepOutput;
+    scrapeInstagramPosts: ScrapeInstagramPostsStepOutput;
+    scrapeInstagramProfile: ScrapeInstagramProfileStepOutput;
+    scrapeInstagramReels: ScrapeInstagramReelsStepOutput;
+    scrapeLinkedInCompany: ScrapeLinkedInCompanyStepOutput;
+    scrapeLinkedInProfile: ScrapeLinkedInProfileStepOutput;
+    scrapeMetaThreadsProfile: ScrapeMetaThreadsProfileStepOutput;
+    scrapeUrl: ScrapeUrlStepOutput;
+    scrapeXPost: ScrapeXPostStepOutput;
+    scrapeXProfile: ScrapeXProfileStepOutput;
+    searchGoogle: SearchGoogleStepOutput;
+    searchGoogleImages: SearchGoogleImagesStepOutput;
+    searchGoogleNews: SearchGoogleNewsStepOutput;
+    searchGoogleTrends: SearchGoogleTrendsStepOutput;
+    searchPerplexity: SearchPerplexityStepOutput;
+    searchXPosts: SearchXPostsStepOutput;
+    searchYoutube: SearchYoutubeStepOutput;
+    searchYoutubeTrends: SearchYoutubeTrendsStepOutput;
+    sendEmail: SendEmailStepOutput;
+    sendSMS: SendSMSStepOutput;
+    setRunTitle: SetRunTitleStepOutput;
+    setVariable: SetVariableStepOutput;
+    telegramSendAudio: TelegramSendAudioStepOutput;
+    telegramSendFile: TelegramSendFileStepOutput;
+    telegramSendImage: TelegramSendImageStepOutput;
+    telegramSendMessage: TelegramSendMessageStepOutput;
+    telegramSendVideo: TelegramSendVideoStepOutput;
+    telegramSetTyping: TelegramSetTypingStepOutput;
+    textToSpeech: TextToSpeechStepOutput;
+    transcribeAudio: TranscribeAudioStepOutput;
+    trimMedia: TrimMediaStepOutput;
+    updateGoogleCalendarEvent: UpdateGoogleCalendarEventStepOutput;
+    updateGoogleDoc: UpdateGoogleDocStepOutput;
+    updateGoogleSheet: UpdateGoogleSheetStepOutput;
+    upscaleImage: UpscaleImageStepOutput;
+    upscaleVideo: UpscaleVideoStepOutput;
+    userMessage: UserMessageStepOutput;
+    videoFaceSwap: VideoFaceSwapStepOutput;
+    videoRemoveBackground: VideoRemoveBackgroundStepOutput;
+    videoRemoveWatermark: VideoRemoveWatermarkStepOutput;
+    watermarkImage: WatermarkImageStepOutput;
+    watermarkVideo: WatermarkVideoStepOutput;
+}
+
+declare module "../client.js" {
+    interface MindStudioAgent {
+        /**
+         * [ActiveCampaign] Add Note
+         *
+         * Add a note to an existing contact in ActiveCampaign.
+         *
+         * ## Usage Notes
+         * - Requires an ActiveCampaign OAuth connection (connectionId).
+         * - The contact must already exist — use the contact ID from a previous create or search step.
+         */
+        activeCampaignAddNote(step: ActiveCampaignAddNoteStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ActiveCampaignAddNoteStepOutput>>;
+        /**
+         * [ActiveCampaign] Create Contact
+         *
+         * Create or sync a contact in ActiveCampaign.
+         *
+         * ## Usage Notes
+         * - Requires an ActiveCampaign OAuth connection (connectionId).
+         * - If a contact with the email already exists, it may be updated depending on ActiveCampaign settings.
+         * - Custom fields are passed as a key-value map where keys are field IDs.
+         */
+        activeCampaignCreateContact(step: ActiveCampaignCreateContactStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ActiveCampaignCreateContactStepOutput>>;
+        /**
+         * Add Subtitles To Video
+         *
+         * Automatically add subtitles to a video
+         *
+         * ## Usage Notes
+         * - Can control style of text and animation
+         */
+        addSubtitlesToVideo(step: AddSubtitlesToVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<AddSubtitlesToVideoStepOutput>>;
+        /**
+         * [Airtable] Create/Update record
+         *
+         * Create a new record or update an existing record in an Airtable table.
+         *
+         * ## Usage Notes
+         * - If recordId is provided, updates that record. Otherwise, creates a new one.
+         * - When updating with updateMode "onlySpecified", unspecified fields are left as-is. With "all", unspecified fields are cleared.
+         * - Array fields (e.g. multipleAttachments) accept arrays of values.
+         */
+        airtableCreateUpdateRecord(step: AirtableCreateUpdateRecordStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<AirtableCreateUpdateRecordStepOutput>>;
+        /**
+         * [Airtable] Delete record
+         *
+         * Delete a record from an Airtable table by its record ID.
+         *
+         * ## Usage Notes
+         * - Requires an active Airtable OAuth connection (connectionId).
+         * - Silently succeeds if the record does not exist.
+         */
+        airtableDeleteRecord(step: AirtableDeleteRecordStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<AirtableDeleteRecordStepOutput>>;
+        /**
+         * [Airtable] Get record
+         *
+         * Fetch a single record from an Airtable table by its record ID.
+         *
+         * ## Usage Notes
+         * - Requires an active Airtable OAuth connection (connectionId).
+         * - If the record is not found, returns a string message instead of a record object.
+         */
+        airtableGetRecord(step: AirtableGetRecordStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<AirtableGetRecordStepOutput>>;
+        /**
+         * [Airtable] Get table records
+         *
+         * Fetch multiple records from an Airtable table with optional pagination.
+         *
+         * ## Usage Notes
+         * - Requires an active Airtable OAuth connection (connectionId).
+         * - Default limit is 100 records. Maximum is 1000.
+         * - When outputFormat is 'csv', the variable receives CSV text. The direct execution output always returns parsed records.
+         */
+        airtableGetTableRecords(step: AirtableGetTableRecordsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<AirtableGetTableRecordsStepOutput>>;
+        /**
+         * Analyze Image
+         *
+         * Analyze an image using a vision model based on a text prompt.
+         *
+         * ## Usage Notes
+         * - Uses the configured vision model to generate a text analysis of the image.
+         * - The prompt should describe what to look for or extract from the image.
+         */
+        analyzeImage(step: AnalyzeImageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<AnalyzeImageStepOutput>>;
+        /**
+         * Analyze Video
+         *
+         * Analyze a video using a video analysis model based on a text prompt.
+         *
+         * ## Usage Notes
+         * - Uses the configured video analysis model to generate a text analysis of the video.
+         * - The prompt should describe what to look for or extract from the video.
+         */
+        analyzeVideo(step: AnalyzeVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<AnalyzeVideoStepOutput>>;
+        /**
+         * Get Image from Video Frame
+         *
+         * Capture a thumbnail from a video at a specified timestamp
+         *
+         * ## Usage Notes
+         *
+         */
+        captureThumbnail(step: CaptureThumbnailStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<CaptureThumbnailStepOutput>>;
+        /**
+         * [Coda] Create/Update page
+         *
+         * Create a new page or update an existing page in a Coda document.
+         *
+         * ## Usage Notes
+         * - Requires a Coda OAuth connection (connectionId).
+         * - If pageData.pageId is provided, updates that page. Otherwise, creates a new one.
+         * - Page content is provided as markdown and converted to Coda's canvas format.
+         * - When updating, insertionMode controls how content is applied (default: 'append').
+         */
+        codaCreateUpdatePage(step: CodaCreateUpdatePageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<CodaCreateUpdatePageStepOutput>>;
+        /**
+         * [Coda] Create/Update row
+         *
+         * Create a new row or update an existing row in a Coda table.
+         *
+         * ## Usage Notes
+         * - Requires a Coda OAuth connection (connectionId).
+         * - If rowId is provided, updates that row. Otherwise, creates a new one.
+         * - Row data keys are column IDs. Empty values are excluded.
+         */
+        codaCreateUpdateRow(step: CodaCreateUpdateRowStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<CodaCreateUpdateRowStepOutput>>;
+        /**
+         * [Coda] Find row
+         *
+         * Search for a row in a Coda table by matching column values.
+         *
+         * ## Usage Notes
+         * - Requires a Coda OAuth connection (connectionId).
+         * - Returns the first row matching all specified column values, or null if no match.
+         * - Search criteria in rowData are ANDed together.
+         */
+        codaFindRow(step: CodaFindRowStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<CodaFindRowStepOutput>>;
+        /**
+         * [Coda] Get page
+         *
+         * Export and read the contents of a page from a Coda document.
+         *
+         * ## Usage Notes
+         * - Requires a Coda OAuth connection (connectionId).
+         * - Page export is asynchronous on Coda's side — there may be a brief delay while it processes.
+         * - If a page was just created in a prior step, there is an automatic 20-second retry if the first export attempt fails.
+         */
+        codaGetPage(step: CodaGetPageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<CodaGetPageStepOutput>>;
+        /**
+         * [Coda] Get table rows
+         *
+         * Fetch rows from a Coda table with optional pagination.
+         *
+         * ## Usage Notes
+         * - Requires a Coda OAuth connection (connectionId).
+         * - Default limit is 10000 rows. Rows are fetched in pages of 500.
+         * - When outputFormat is 'csv', the variable receives CSV text. The direct execution output always returns parsed rows.
+         */
+        codaGetTableRows(step: CodaGetTableRowsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<CodaGetTableRowsStepOutput>>;
+        /**
+         * Convert PDF to Images
+         *
+         * Convert each page of a PDF document into a PNG image.
+         *
+         * ## Usage Notes
+         * - Each page is converted to a separate PNG and re-hosted on the CDN.
+         * - Returns an array of image URLs, one per page.
+         */
+        convertPdfToImages(step: ConvertPdfToImagesStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ConvertPdfToImagesStepOutput>>;
+        /**
+         * [Google Calendar] Create Event
+         *
+         * Create a new event on a Google Calendar.
+         *
+         * ## Usage Notes
+         * - Requires a Google OAuth connection with Calendar events scope.
+         * - Date/time values must be ISO 8601 format (e.g. "2025-07-02T10:00:00-07:00").
+         * - Attendees are specified as one email address per line in a single string.
+         * - Set addMeetLink to true to automatically attach a Google Meet video call.
+         */
+        createGoogleCalendarEvent(step: CreateGoogleCalendarEventStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<CreateGoogleCalendarEventStepOutput>>;
+        /**
+         * [Google] Create Google Doc
+         *
+         * Create a new Google Document and optionally populate it with content.
+         *
+         * ## Usage Notes
+         * - textType determines how the text field is interpreted: "plain" for plain text, "html" for HTML markup, "markdown" for Markdown.
+         */
+        createGoogleDoc(step: CreateGoogleDocStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<CreateGoogleDocStepOutput>>;
+        /**
+         * [Google] Create Google Sheet
+         *
+         * Create a new Google Spreadsheet and populate it with CSV data.
+         */
+        createGoogleSheet(step: CreateGoogleSheetStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<CreateGoogleSheetStepOutput>>;
+        /**
+         * [Google Calendar] Get Event
+         *
+         * Retrieve a specific event from a Google Calendar by event ID.
+         *
+         * ## Usage Notes
+         * - Requires a Google OAuth connection with Calendar events scope.
+         * - The variable receives JSON or XML-like text depending on exportType. The direct execution output always returns the structured event.
+         */
+        deleteGoogleCalendarEvent(step: DeleteGoogleCalendarEventStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<DeleteGoogleCalendarEventStepOutput>>;
+        /**
+         * Detect PII
+         *
+         * Scan text for personally identifiable information using Microsoft Presidio.
+         *
+         * ## Usage Notes
+         * - In workflow mode, transitions to detectedStepId if PII is found, notDetectedStepId otherwise.
+         * - In direct execution, returns the detection results without transitioning.
+         * - If entities is empty, returns immediately with no detections.
+         */
+        detectPII(step: DetectPIIStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<DetectPIIStepOutput>>;
+        /**
+         * Download Video
+         *
+         * Download a video file
+         *
+         * ## Usage Notes
+         * - Works with YouTube, TikTok, etc., by using ytdlp behind the scenes
+         * - Can save as mp4 or mp3
+         */
+        downloadVideo(step: DownloadVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<DownloadVideoStepOutput>>;
+        /**
+         * Enhance Image Prompt
+         *
+         * Auto-enhance an image generation prompt using a language model. Optionally generates a negative prompt.
+         *
+         * ## Usage Notes
+         * - Rewrites the user's prompt with added detail about style, lighting, colors, and composition.
+         * - When includeNegativePrompt is true, a second model call generates a negative prompt.
+         */
+        enhanceImageGenerationPrompt(step: EnhanceImageGenerationPromptStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<EnhanceImageGenerationPromptStepOutput>>;
+        /**
+         * Enhance Video Prompt
+         *
+         * Auto-enhance a video generation prompt using a language model. Optionally generates a negative prompt.
+         *
+         * ## Usage Notes
+         * - Rewrites the user's prompt with added detail about style, camera movement, lighting, and composition.
+         * - When includeNegativePrompt is true, a second model call generates a negative prompt.
+         */
+        enhanceVideoGenerationPrompt(step: EnhanceVideoGenerationPromptStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<EnhanceVideoGenerationPromptStepOutput>>;
+        /**
+         * [Apollo] Enrich Person
+         *
+         * Look up professional information about a person using Apollo.io. Search by ID, name, LinkedIn URL, email, or domain.
+         *
+         * ## Usage Notes
+         * - At least one search parameter must be provided.
+         * - Returns enriched data from Apollo including contact details, employment info, and social profiles.
+         */
+        enrichPerson(step: EnrichPersonStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<EnrichPersonStepOutput>>;
+        /**
+         * Extract Audio from Video
+         *
+         * Extract audio MP3 from a video file
+         *
+         * ## Usage Notes
+         *
+         */
+        extractAudioFromVideo(step: ExtractAudioFromVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ExtractAudioFromVideoStepOutput>>;
+        /**
+         * Extract Text from URL
+         *
+         * Download a file from a URL and extract its text content. Supports PDFs, plain text files, and other document formats.
+         *
+         * ## Usage Notes
+         * - Best suited for PDFs and raw text/document files. For web pages, use the scrapeUrl step instead.
+         * - Accepts a single URL, a comma-separated list of URLs, or a JSON array of URLs.
+         * - Files are rehosted on the MindStudio CDN before extraction.
+         * - Maximum file size is 50MB per URL.
+         */
+        extractText(step: ExtractTextStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ExtractTextStepOutput>>;
+        /**
+         * [Google] Fetch Google Doc
+         *
+         * Fetch the contents of an existing Google Document.
+         *
+         * ## Usage Notes
+         * - exportType controls the output format: "html" for HTML markup, "markdown" for Markdown, "json" for structured JSON, "plain" for plain text.
+         */
+        fetchGoogleDoc(step: FetchGoogleDocStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<FetchGoogleDocStepOutput>>;
+        /**
+         * [Google] Fetch Google Sheet
+         *
+         * Fetch contents of a Google Spreadsheet range.
+         *
+         * ## Usage Notes
+         * - range uses A1 notation (e.g. "Sheet1!A1:C10"). Omit to fetch the entire first sheet.
+         * - exportType controls the output format: "csv" for comma-separated values, "json" for structured JSON.
+         */
+        fetchGoogleSheet(step: FetchGoogleSheetStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<FetchGoogleSheetStepOutput>>;
+        /**
+         * Fetch Slack Channel History
+         *
+         * Fetch recent message history from a Slack channel.
+         *
+         * ## Usage Notes
+         * - The user is responsible for connecting their Slack workspace and selecting the channel
+         */
+        fetchSlackChannelHistory(step: FetchSlackChannelHistoryStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<FetchSlackChannelHistoryStepOutput>>;
+        /**
+         * [YouTube] Fetch Captions
+         *
+         * Retrieve the captions/transcript for a YouTube video.
+         *
+         * ## Usage Notes
+         * - Supports multiple languages via the language parameter.
+         * - "text" export produces timestamped plain text; "json" export produces structured transcript data.
+         */
+        fetchYoutubeCaptions(step: FetchYoutubeCaptionsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<FetchYoutubeCaptionsStepOutput>>;
+        /**
+         * [YouTube] Fetch Channel
+         *
+         * Retrieve metadata and recent videos for a YouTube channel.
+         *
+         * ## Usage Notes
+         * - Accepts a YouTube channel URL (e.g. https://www.youtube.com/@ChannelName or /channel/ID).
+         * - Returns channel info and video listings as a JSON object.
+         */
+        fetchYoutubeChannel(step: FetchYoutubeChannelStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<FetchYoutubeChannelStepOutput>>;
+        /**
+         * [YouTube] Fetch Comments
+         *
+         * Retrieve comments for a YouTube video.
+         *
+         * ## Usage Notes
+         * - Paginates through comments (up to 5 pages).
+         * - "text" export produces markdown-formatted text; "json" export produces structured comment data.
+         */
+        fetchYoutubeComments(step: FetchYoutubeCommentsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<FetchYoutubeCommentsStepOutput>>;
+        /**
+         * [YouTube] Fetch Video
+         *
+         * Retrieve metadata for a YouTube video (title, description, stats, channel info).
+         *
+         * ## Usage Notes
+         * - Returns video metadata, channel info, and engagement stats.
+         * - Video format data is excluded from the response.
+         */
+        fetchYoutubeVideo(step: FetchYoutubeVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<FetchYoutubeVideoStepOutput>>;
+        /**
+         * Generate Chart
+         *
+         * Create a chart image using QuickChart (Chart.js) and return the URL.
+         *
+         * ## Usage Notes
+         * - The data field must be a Chart.js-compatible JSON object serialized as a string.
+         * - Supported chart types: bar, line, pie.
+         */
+        generateChart(step: GenerateChartStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<GenerateChartStepOutput>>;
+        /**
+         * Generate Image
+         *
+         * Generate an image from a text prompt using an AI model.
+         *
+         * ## Usage Notes
+         * - Prompts should be descriptive but concise (roughly 3–6 sentences).
+         * - Images are automatically hosted on a CDN.
+         * - In foreground mode, the image is displayed to the user. In background mode, the URL is saved to a variable.
+         * - When generateVariants is true with numVariants > 1, multiple images are generated in parallel.
+         * - In direct execution, foreground mode behaves as background, and userSelect variant behavior behaves as saveAll.
+         */
+        generateImage(step: GenerateImageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<GenerateImageStepOutput>>;
+        /**
+         * Generate Lipsync
+         *
+         * Generate a lip sync video from provided audio and image.
+         *
+         * ## Usage Notes
+         * - In foreground mode, the video is displayed to the user. In background mode, the URL is saved to a variable.
+         */
+        generateLipsync(step: GenerateLipsyncStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<GenerateLipsyncStepOutput>>;
+        /**
+         * Generate Music
+         *
+         * Generate an audio file from provided instructions (text) using a music model.
+         *
+         * ## Usage Notes
+         * - The text field contains the instructions (prompt) for the music generation.
+         * - In foreground mode, the audio is displayed to the user. In background mode, the URL is saved to a variable.
+         */
+        generateMusic(step: GenerateMusicStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<GenerateMusicStepOutput>>;
+        /**
+         * Generate HTML Asset
+         *
+         * Generate an HTML asset and export it as a webpage, PDF, or image
+         *
+         * ## Usage Notes
+         * - Agents can generate HTML documents and export as webpage, PDFs, images, or videos. They do this by using the "generatePdf" block, which defines an HTML page with variables, and then the generation process renders the page to create the output and save its URL at the specified variable.
+         * - The template for the HTML page is generated by a separate process, and it can only use variables that have already been defined in the workflow at the time of its execution. It has full access to handlebars to render the HTML template, including a handlebars helper to render a markdown variable string as HTML (which can be useful for creating templates that render long strings). The template can also create its own simple JavaScript to do things like format dates and strings.
+         * - If PDF or composited image generation are part of the workflow, assistant adds the block and leaves the "source" empty. In a separate step, assistant generates a detailed request for the developer who will write the HTML.
+         * - Can also auto-generate HTML from a prompt (like a generate text block to generate HTML). In these cases, create a prompt with variables in the dynamicPrompt variable describing, in detail, the document to generate
+         * - Can either display output directly to user (foreground mode) or save the URL of the asset to a variable (background mode)
+         */
+        generatePdf(step: GeneratePdfStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<GeneratePdfStepOutput>>;
+        /**
+         * Generate Static Video from Image
+         *
+         * Convert a static image to an MP4
+         *
+         * ## Usage Notes
+         * - Can use to create slides/intertitles/slates for video composition
+         */
+        generateStaticVideoFromImage(step: GenerateStaticVideoFromImageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<GenerateStaticVideoFromImageStepOutput>>;
+        /**
+         * Generate Video
+         *
+         * Generate a video from a text prompt using an AI model.
+         *
+         * ## Usage Notes
+         * - Prompts should be descriptive but concise (roughly 3–6 sentences).
+         * - Videos are automatically hosted on a CDN.
+         * - In foreground mode, the video is displayed to the user. In background mode, the URL is saved to a variable.
+         * - When generateVariants is true with numVariants > 1, multiple videos are generated in parallel.
+         * - In direct execution, foreground mode behaves as background, and userSelect variant behavior behaves as saveAll.
+         */
+        generateVideo(step: GenerateVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<GenerateVideoStepOutput>>;
+        /**
+         * [Google Calendar] Get Event
+         *
+         * Retrieve a specific event from a Google Calendar by event ID.
+         *
+         * ## Usage Notes
+         * - Requires a Google OAuth connection with Calendar events scope.
+         * - The variable receives JSON or XML-like text depending on exportType. The direct execution output always returns the structured event.
+         */
+        getGoogleCalendarEvent(step: GetGoogleCalendarEventStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<GetGoogleCalendarEventStepOutput>>;
+        /**
+         * Get Media Metadata
+         *
+         * Get info about a media file
+         *
+         * ## Usage Notes
+         *
+         */
+        getMediaMetadata(step: GetMediaMetadataStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<GetMediaMetadataStepOutput>>;
+        /**
+         * HTTP Request
+         *
+         * Make an HTTP request to an external endpoint and return the response.
+         *
+         * ## Usage Notes
+         * - Supports GET, POST, PATCH, DELETE, and PUT methods.
+         * - Body can be raw JSON/text, URL-encoded form data, or multipart form data.
+         */
+        httpRequest(step: HttpRequestStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HttpRequestStepOutput>>;
+        /**
+         * [HubSpot] Create/Update Company
+         *
+         * Create a new company or update an existing one in HubSpot. Matches by domain.
+         *
+         * ## Usage Notes
+         * - Requires a HubSpot OAuth connection (connectionId).
+         * - If a company with the given domain already exists, it is updated. Otherwise, a new one is created.
+         * - Property values are type-checked against enabledProperties before being sent to HubSpot.
+         */
+        hubspotCreateCompany(step: HubspotCreateCompanyStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HubspotCreateCompanyStepOutput>>;
+        /**
+         * [HubSpot] Create/Update Contact
+         *
+         * Create a new contact or update an existing one in HubSpot. Matches by email address.
+         *
+         * ## Usage Notes
+         * - Requires a HubSpot OAuth connection (connectionId).
+         * - If a contact with the given email already exists, it is updated. Otherwise, a new one is created.
+         * - If companyDomain is provided, the contact is associated with that company (creating the company if needed).
+         * - Property values are type-checked against enabledProperties before being sent to HubSpot.
+         */
+        hubspotCreateContact(step: HubspotCreateContactStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HubspotCreateContactStepOutput>>;
+        /**
+         * [HubSpot] Get Company
+         *
+         * Look up a HubSpot company by domain name or company ID.
+         *
+         * ## Usage Notes
+         * - Requires a HubSpot OAuth connection (connectionId).
+         * - Returns null if the company is not found.
+         * - When searching by domain, performs a search query then fetches the full company record.
+         * - Use additionalProperties to request specific HubSpot properties beyond the defaults.
+         */
+        hubspotGetCompany(step: HubspotGetCompanyStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HubspotGetCompanyStepOutput>>;
+        /**
+         * [HubSpot] Get Contact
+         *
+         * Look up a HubSpot contact by email address or contact ID.
+         *
+         * ## Usage Notes
+         * - Requires a HubSpot OAuth connection (connectionId).
+         * - Returns null if the contact is not found.
+         * - Use additionalProperties to request specific HubSpot properties beyond the defaults.
+         */
+        hubspotGetContact(step: HubspotGetContactStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HubspotGetContactStepOutput>>;
+        /**
+         * [Hunter.io] Enrich Company
+         *
+         * Look up company information by domain using Hunter.io.
+         *
+         * ## Usage Notes
+         * - Returns company name, description, location, industry, size, technologies, and more.
+         * - If the domain input is a full URL, the hostname is automatically extracted.
+         * - Returns null if the company is not found.
+         */
+        hunterApiCompanyEnrichment(step: HunterApiCompanyEnrichmentStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HunterApiCompanyEnrichmentStepOutput>>;
+        /**
+         * [Hunter.io] Domain Search
+         *
+         * Search for email addresses associated with a domain using Hunter.io.
+         *
+         * ## Usage Notes
+         * - If the domain input is a full URL, the hostname is automatically extracted.
+         * - Returns a list of email addresses found for the domain along with organization info.
+         */
+        hunterApiDomainSearch(step: HunterApiDomainSearchStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HunterApiDomainSearchStepOutput>>;
+        /**
+         * [Hunter.io] Find Email
+         *
+         * Find an email address for a specific person at a domain using Hunter.io.
+         *
+         * ## Usage Notes
+         * - Requires a first name, last name, and domain.
+         * - If the domain input is a full URL, the hostname is automatically extracted.
+         * - Returns the most likely email address with a confidence score.
+         */
+        hunterApiEmailFinder(step: HunterApiEmailFinderStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HunterApiEmailFinderStepOutput>>;
+        /**
+         * [Hunter.io] Verify Email
+         *
+         * Verify whether an email address is valid and deliverable using Hunter.io.
+         *
+         * ## Usage Notes
+         * - Checks email format, MX records, SMTP server, and mailbox deliverability.
+         * - Returns a status ("valid", "invalid", "accept_all", "webmail", "disposable", "unknown") and a score.
+         */
+        hunterApiEmailVerification(step: HunterApiEmailVerificationStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HunterApiEmailVerificationStepOutput>>;
+        /**
+         * [Hunter.io] Enrich Person
+         *
+         * Look up professional information about a person by their email address using Hunter.io.
+         *
+         * ## Usage Notes
+         * - Returns name, job title, social profiles, and company information.
+         * - If the person is not found, returns an object with an error message instead of throwing.
+         */
+        hunterApiPersonEnrichment(step: HunterApiPersonEnrichmentStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<HunterApiPersonEnrichmentStepOutput>>;
+        /**
+         * Image Face Swap
+         *
+         * Replace a face in an image with a face from another image using AI.
+         *
+         * ## Usage Notes
+         * - Requires both a target image and a face source image.
+         * - Output is re-hosted on the CDN as a PNG.
+         */
+        imageFaceSwap(step: ImageFaceSwapStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ImageFaceSwapStepOutput>>;
+        /**
+         * Remove Image Watermark
+         *
+         * Remove watermarks from an image using AI.
+         *
+         * ## Usage Notes
+         * - Output is re-hosted on the CDN as a PNG.
+         */
+        imageRemoveWatermark(step: ImageRemoveWatermarkStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ImageRemoveWatermarkStepOutput>>;
+        /**
+         * Insert Video Clips
+         *
+         * Insert b-roll clips into a base video at a timecode, optionally with an xfade transition.
+         *
+         * ## Usage Notes
+         *
+         */
+        insertVideoClips(step: InsertVideoClipsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<InsertVideoClipsStepOutput>>;
+        /**
+         * [Google Calendar] List Events
+         *
+         * List upcoming events from a Google Calendar, ordered by start time.
+         *
+         * ## Usage Notes
+         * - Requires a Google OAuth connection with Calendar events scope.
+         * - Only returns future events (timeMin = now).
+         * - The variable receives JSON or XML-like text depending on exportType. The direct execution output always returns structured events.
+         */
+        listGoogleCalendarEvents(step: ListGoogleCalendarEventsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ListGoogleCalendarEventsStepOutput>>;
+        /**
+         * Evaluate Logic
+         *
+         * Use an AI model to evaluate which condition from a list is most true, given a context prompt.
+         *
+         * ## Usage Notes
+         * - This is "fuzzy" logic evaluated by an AI model, not computational logic. The model picks the most accurate statement.
+         * - All possible cases must be specified — there is no default/fallback case.
+         * - Requires at least two cases.
+         * - In workflow mode, transitions to the destinationStepId of the winning case. In direct execution, returns the winning case ID and condition.
+         */
+        logic(step: LogicStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<LogicStepOutput>>;
+        /**
+         * Make.com Run Scenario
+         *
+         * Trigger a Make.com (formerly Integromat) scenario via webhook and return the response.
+         *
+         * ## Usage Notes
+         * - The webhook URL must be configured in your Make.com scenario.
+         * - Input key-value pairs are sent as JSON in the POST body.
+         * - Response format depends on the Make.com scenario configuration.
+         */
+        makeDotComRunScenario(step: MakeDotComRunScenarioStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<MakeDotComRunScenarioStepOutput>>;
+        /**
+         * Merge Audio
+         *
+         * Merge one or more clips into a single audio file.
+         *
+         * ## Usage Notes
+         *
+         */
+        mergeAudio(step: MergeAudioStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<MergeAudioStepOutput>>;
+        /**
+         * Merge Videos
+         *
+         * Merge one or more clips into a single video.
+         *
+         * ## Usage Notes
+         *
+         */
+        mergeVideos(step: MergeVideosStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<MergeVideosStepOutput>>;
+        /**
+         * Mix Audio into Video
+         *
+         * Mix an audio track into a video
+         *
+         * ## Usage Notes
+         *
+         */
+        mixAudioIntoVideo(step: MixAudioIntoVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<MixAudioIntoVideoStepOutput>>;
+        /**
+         * Mute Video
+         *
+         * Mute a video file
+         *
+         * ## Usage Notes
+         *
+         */
+        muteVideo(step: MuteVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<MuteVideoStepOutput>>;
+        /**
+         * N8N Run Node
+         *
+         * Trigger an n8n workflow node via webhook and return the response.
+         *
+         * ## Usage Notes
+         * - The webhook URL must be configured in your n8n workflow.
+         * - Supports GET and POST methods with optional Basic authentication.
+         * - For GET requests, input values are sent as query parameters. For POST, they are sent as JSON body.
+         */
+        n8nRunNode(step: N8nRunNodeStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<N8nRunNodeStepOutput>>;
+        /**
+         * [Notion] Create Page
+         *
+         * Create a new page in Notion as a child of an existing page.
+         *
+         * ## Usage Notes
+         * - Requires a Notion OAuth connection (connectionId).
+         * - Content is provided as markdown and converted to Notion blocks (headings, paragraphs, lists, code, quotes).
+         * - The page is created as a child of the specified parent page (pageId).
+         */
+        notionCreatePage(step: NotionCreatePageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<NotionCreatePageStepOutput>>;
+        /**
+         * [Notion] Update Page
+         *
+         * Update the content of an existing Notion page.
+         *
+         * ## Usage Notes
+         * - Requires a Notion OAuth connection (connectionId).
+         * - Content is provided as markdown and converted to Notion blocks.
+         * - "append" mode adds content to the end of the page. "overwrite" mode deletes all existing blocks first.
+         */
+        notionUpdatePage(step: NotionUpdatePageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<NotionUpdatePageStepOutput>>;
+        /**
+         * [Apollo] People Search
+         *
+         * Search for people matching specific criteria using Apollo.io. Supports natural language queries and advanced filters.
+         *
+         * ## Usage Notes
+         * - Can use a natural language "smartQuery" which is converted to Apollo search parameters by an AI model.
+         * - Advanced params can override or supplement the smart query results.
+         * - Optionally enriches returned people and/or their organizations for additional detail.
+         * - Results are paginated. Use limit and page to control the result window.
+         */
+        peopleSearch(step: PeopleSearchStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<PeopleSearchStepOutput>>;
+        /**
+         * [LinkedIn] Create post
+         *
+         * Create a post on LinkedIn from the connected account.
+         *
+         * ## Usage Notes
+         * - Requires a LinkedIn OAuth connection (connectionId).
+         * - Supports text posts, image posts, and video posts.
+         * - Visibility controls who can see the post.
+         */
+        postToLinkedIn(step: PostToLinkedInStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<PostToLinkedInStepOutput>>;
+        /**
+         * Post to Slack Channel
+         *
+         * Send a message to a Slack channel via a connected bot.
+         *
+         * ## Usage Notes
+         * - The user is responsible for connecting their Slack workspace and selecting the channel
+         * - Supports both simple text messages and slack blocks messages
+         * - Text messages can use limited markdown (slack-only fomatting—e.g., headers are just rendered as bold)
+         */
+        postToSlackChannel(step: PostToSlackChannelStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<PostToSlackChannelStepOutput>>;
+        /**
+         * [X] Create post
+         *
+         * Create a post on X (Twitter) from the connected account.
+         *
+         * ## Usage Notes
+         * - Requires an X OAuth connection (connectionId).
+         * - Posts are plain text. Maximum 280 characters.
+         */
+        postToX(step: PostToXStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<PostToXStepOutput>>;
+        /**
+         * Post to Zapier
+         *
+         * Send data to a Zapier Zap via webhook and return the response.
+         *
+         * ## Usage Notes
+         * - The webhook URL must be configured in the Zapier Zap settings
+         * - Input keys and values are sent as the JSON body of the POST request
+         * - The webhook response (JSON or plain text) is returned as the output
+         */
+        postToZapier(step: PostToZapierStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<PostToZapierStepOutput>>;
+        /**
+         * Query Data Source
+         *
+         * Search a vector data source (RAG) and return relevant document chunks.
+         *
+         * ## Usage Notes
+         * - Queries a vectorized data source and returns the most relevant chunks.
+         * - Useful for retrieval-augmented generation (RAG) workflows.
+         */
+        queryDataSource(step: QueryDataSourceStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<QueryDataSourceStepOutput>>;
+        /**
+         * Query External SQL Database
+         *
+         * Execute a SQL query against an external database connected to the workspace.
+         *
+         * ## Usage Notes
+         * - Requires a database connection configured in the workspace.
+         * - Supports PostgreSQL (including Supabase), MySQL, and MSSQL.
+         * - Results can be returned as JSON or CSV.
+         */
+        queryExternalDatabase(step: QueryExternalDatabaseStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<QueryExternalDatabaseStepOutput>>;
+        /**
+         * Redact PII
+         *
+         * Replace personally identifiable information in text with placeholders using Microsoft Presidio.
+         *
+         * ## Usage Notes
+         * - PII is replaced with entity type placeholders (e.g. "Call me at <PHONE_NUMBER>").
+         * - If entities is empty, returns empty text immediately without processing.
+         */
+        redactPII(step: RedactPIIStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<RedactPIIStepOutput>>;
+        /**
+         * Remove Background From Image
+         *
+         * Remove the background from an image using AI, producing a transparent PNG.
+         *
+         * ## Usage Notes
+         * - Uses the Bria background removal model via fal.ai.
+         * - Output is re-hosted on the CDN as a PNG with transparency.
+         */
+        removeBackgroundFromImage(step: RemoveBackgroundFromImageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<RemoveBackgroundFromImageStepOutput>>;
+        /**
+         * Resize Video
+         *
+         * Resize a video file
+         *
+         * ## Usage Notes
+         *
+         */
+        resizeVideo(step: ResizeVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ResizeVideoStepOutput>>;
+        /**
+         * Run Packaged Workflow
+         *
+         * Run a packaged workflow ("custom block")
+         *
+         * ## Usage Notes
+         * - From the user's perspective, packaged workflows are just ordinary blocks. Behind the scenes, they operate like packages/libraries in a programming language, letting the user execute custom functionality.
+         * - Some of these packaged workflows are available as part of MindStudio's "Standard Library" and available to every user.
+         * - Available packaged workflows are documented here as individual blocks, but the runPackagedWorkflow block is how they need to be wrapped in order to be executed correctly.
+         */
+        runPackagedWorkflow(step: RunPackagedWorkflowStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<RunPackagedWorkflowStepOutput>>;
+        /**
+         * Run Workflow
+         *
+         * Spawn one or more child workflows (advanced)
+         *
+         * ## Usage Notes
+         * - Spawned workflows are executed in their own contexts and scopes, they do not have access to any variables etc from the parent workflow
+         * - This is an ADVANCED feature and should not be used unless you really know what you are doing
+         * - Child workflows must be set up to receive launch variables and return variables via an end block. The input and output variables properties map variables between scopes
+         */
+        runWorkflow(step: RunWorkflowStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<RunWorkflowStepOutput>>;
+        /**
+         * [Facebook] Scrape Page
+         *
+         * Scrape a Facebook page
+         */
+        scrapeFacebookPage(step: ScrapeFacebookPageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeFacebookPageStepOutput>>;
+        /**
+         * [Facebook] Scrape Posts for Page
+         *
+         * Get all the posts for a Facebook page
+         */
+        scrapeFacebookPosts(step: ScrapeFacebookPostsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeFacebookPostsStepOutput>>;
+        /**
+         * [Instagram] Scrape Comments
+         *
+         * Get all the comments for an Instagram post
+         */
+        scrapeInstagramComments(step: ScrapeInstagramCommentsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeInstagramCommentsStepOutput>>;
+        /**
+         * [Instagram] Scrape Mentions
+         *
+         * Scrape an Instagram profile's mentions
+         */
+        scrapeInstagramMentions(step: ScrapeInstagramMentionsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeInstagramMentionsStepOutput>>;
+        /**
+         * [Instagram] Scrape Posts
+         *
+         * Get all the posts for an Instagram profile
+         */
+        scrapeInstagramPosts(step: ScrapeInstagramPostsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeInstagramPostsStepOutput>>;
+        /**
+         * [Instagram] Scrape Profile
+         *
+         * Scrape an Instagram profile
+         */
+        scrapeInstagramProfile(step: ScrapeInstagramProfileStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeInstagramProfileStepOutput>>;
+        /**
+         * [Instagram] Scrape Reels
+         *
+         * Get all the reels for an Instagram profile
+         */
+        scrapeInstagramReels(step: ScrapeInstagramReelsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeInstagramReelsStepOutput>>;
+        /**
+         * Scrape LinkedIn Company
+         *
+         * Scrape public company data from a LinkedIn company page.
+         *
+         * ## Usage Notes
+         * - Requires a LinkedIn company URL (e.g. https://www.linkedin.com/company/mindstudioai).
+         * - Returns structured company data including description, employees, updates, and similar companies.
+         */
+        scrapeLinkedInCompany(step: ScrapeLinkedInCompanyStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeLinkedInCompanyStepOutput>>;
+        /**
+         * Scrape LinkedIn Profile
+         *
+         * Scrape public profile data from a LinkedIn profile page.
+         *
+         * ## Usage Notes
+         * - Requires a LinkedIn profile URL (e.g. https://www.linkedin.com/in/username).
+         * - Returns structured profile data including experience, education, articles, and activities.
+         */
+        scrapeLinkedInProfile(step: ScrapeLinkedInProfileStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeLinkedInProfileStepOutput>>;
+        /**
+         * [Meta Threads] Scrape Profile
+         *
+         * Scrape a Meta Threads profile
+         */
+        scrapeMetaThreadsProfile(step: ScrapeMetaThreadsProfileStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeMetaThreadsProfileStepOutput>>;
+        /**
+         * Scrape URL
+         *
+         * Extract text, HTML, or structured content from one or more web pages.
+         *
+         * ## Usage Notes
+         * - Accepts a single URL or multiple URLs (as a JSON array, comma-separated, or newline-separated).
+         * - Output format controls the result shape: "text" returns markdown, "html" returns raw HTML, "json" returns structured scraper data.
+         * - Can optionally capture a screenshot of each page.
+         */
+        scrapeUrl(step: ScrapeUrlStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeUrlStepOutput>>;
+        /**
+         * Scrape X Post
+         *
+         * Scrape data from a single X (Twitter) post by URL.
+         *
+         * ## Usage Notes
+         * - Returns structured post data (text, html, optional json/screenshot/metadata).
+         * - Optionally saves the text content to a variable.
+         */
+        scrapeXPost(step: ScrapeXPostStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeXPostStepOutput>>;
+        /**
+         * Scrape X Profile
+         *
+         * Scrape public profile data from an X (Twitter) account by URL.
+         *
+         * ## Usage Notes
+         * - Returns structured profile data.
+         * - Optionally saves the result to a variable.
+         */
+        scrapeXProfile(step: ScrapeXProfileStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<ScrapeXProfileStepOutput>>;
+        /**
+         * Search Google
+         *
+         * Search the web using Google and return structured results.
+         *
+         * ## Usage Notes
+         * - Defaults to us/english, but can optionally specify country and/or language.
+         * - Defaults to any time, but can optionally specify last hour, last day, week, month, or year.
+         * - Defaults to top 30 results, but can specify 1 to 100 results to return.
+         */
+        searchGoogle(step: SearchGoogleStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SearchGoogleStepOutput>>;
+        /**
+         * Search Google Images
+         *
+         * Search Google Images and return image results with URLs and metadata.
+         *
+         * ## Usage Notes
+         * - Defaults to us/english, but can optionally specify country and/or language.
+         * - Defaults to any time, but can optionally specify last hour, last day, week, month, or year.
+         * - Defaults to top 30 results, but can specify 1 to 100 results to return.
+         */
+        searchGoogleImages(step: SearchGoogleImagesStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SearchGoogleImagesStepOutput>>;
+        /**
+         * Search Google News
+         *
+         * Search Google News for recent news articles matching a query.
+         *
+         * ## Usage Notes
+         * - Defaults to top 30 results, but can specify 1 to 100 results to return.
+         */
+        searchGoogleNews(step: SearchGoogleNewsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SearchGoogleNewsStepOutput>>;
+        /**
+         * Search Google Trends
+         *
+         * Fetch Google Trends data for a search term.
+         *
+         * ## Usage Notes
+         * - date accepts shorthand ("now 1-H", "today 1-m", "today 5-y", etc.) or custom "yyyy-mm-dd yyyy-mm-dd" ranges.
+         * - data_type controls the shape of returned data: TIMESERIES, GEO_MAP, GEO_MAP_0, RELATED_TOPICS, or RELATED_QUERIES.
+         */
+        searchGoogleTrends(step: SearchGoogleTrendsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SearchGoogleTrendsStepOutput>>;
+        /**
+         * Search Perplexity
+         *
+         * Search the web using the Perplexity API and return structured results.
+         *
+         * ## Usage Notes
+         * - Defaults to US results. Use countryCode (ISO code) to filter by country.
+         * - Returns 10 results by default, configurable from 1 to 20.
+         * - The variable receives text or JSON depending on exportType. The direct execution output always returns structured results.
+         */
+        searchPerplexity(step: SearchPerplexityStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SearchPerplexityStepOutput>>;
+        /**
+         * [X] Search Posts
+         *
+         * Search recent X (Twitter) posts matching a query.
+         *
+         * ## Usage Notes
+         * - Searches only the past 7 days of posts.
+         * - Query supports X API v2 search operators (up to 512 characters).
+         *
+         * Available search operators in query:
+         *
+         * | Operator         | Description                                      |
+         * | -----------------| -------------------------------------------------|
+         * | from:            | Posts from a specific user (e.g., from:elonmusk) |
+         * | to:              | Posts sent to a specific user (e.g., to:NASA)    |
+         * | @                | Mentions a user (e.g., @openai)                  |
+         * | #                | Hashtag search (e.g., #AI)                       |
+         * | is:retweet       | Filters retweets                                 |
+         * | is:reply         | Filters replies                                  |
+         * | has:media        | Posts containing media (images, videos, or GIFs) |
+         * | has:links        | Posts containing URLs                            |
+         * | lang:            | Filters by language (e.g., lang:en)              |
+         * | -                | Excludes specific terms (e.g., -spam)            |
+         * | ()               | Groups terms or operators (e.g., (AI OR ML))     |
+         * | AND, OR, NOT     | Boolean logic for combining or excluding terms   |
+         *
+         * Conjunction-Required Operators (must be combined with a standalone operator):
+         *
+         * | Operator     | Description                                    |
+         * | ------------ | -----------------------------------------------|
+         * | has:media  | Posts containing media (images, videos, or GIFs) |
+         * | has:links  | Posts containing URLs                            |
+         * | is:retweet | Filters retweets                                 |
+         * | is:reply   | Filters replies                                  |
+         *
+         * For example, has:media alone is invalid, but #AI has:media is valid.
+         */
+        searchXPosts(step: SearchXPostsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SearchXPostsStepOutput>>;
+        /**
+         * [YouTube] Search Videos
+         *
+         * Search for YouTube videos by keyword.
+         *
+         * ## Usage Notes
+         * - Supports pagination (up to 5 pages) and country/language filters.
+         * - Use the filter/filterType fields for YouTube search parameter (sp) filters.
+         */
+        searchYoutube(step: SearchYoutubeStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SearchYoutubeStepOutput>>;
+        /**
+         * [YouTube] Search Trends
+         *
+         * Retrieve trending videos on YouTube by category and region.
+         *
+         * ## Usage Notes
+         * - Categories: "now" (trending now), "music", "gaming", "films".
+         * - Supports country and language filtering.
+         */
+        searchYoutubeTrends(step: SearchYoutubeTrendsStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SearchYoutubeTrendsStepOutput>>;
+        /**
+         * Send Email
+         *
+         * Send an email to one or more configured recipient addresses.
+         *
+         * ## Usage Notes
+         * - Recipient email addresses are resolved from OAuth connections configured by the app creator. The user running the workflow does not specify the recipient directly.
+         * - If the body is a URL to a hosted HTML file on the CDN, the HTML is fetched and used as the email body.
+         * - When generateHtml is enabled, the body text is converted to a styled HTML email using an AI model.
+         * - connectionId can be a comma-separated list to send to multiple recipients.
+         * - The special connectionId "trigger_email" uses the email address that triggered the workflow.
+         */
+        sendEmail(step: SendEmailStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SendEmailStepOutput>>;
+        /**
+         * Send SMS
+         *
+         * Send an SMS text message to a phone number configured via OAuth connection.
+         *
+         * ## Usage Notes
+         * - User is responsible for configuring the connection to the number (MindStudio requires double opt-in to prevent spam)
+         */
+        sendSMS(step: SendSMSStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SendSMSStepOutput>>;
+        /**
+         * Set Run Title
+         *
+         * Set the title of the agent run for the user's history
+         */
+        setRunTitle(step: SetRunTitleStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SetRunTitleStepOutput>>;
+        /**
+         * Set Variable
+         *
+         * Explicitly set a variable to a given value.
+         *
+         * ## Usage Notes
+         * - Useful for bootstrapping global variables or setting constants.
+         * - The variable name and value both support variable interpolation.
+         * - The type field is a UI hint only (controls input widget in the editor).
+         */
+        setVariable(step: SetVariableStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<SetVariableStepOutput>>;
+        /**
+         * Send Telegram Audio
+         *
+         * Send an audio file to a Telegram chat as music or a voice note via a bot.
+         *
+         * ## Usage Notes
+         * - "audio" mode sends as a standard audio file. "voice" mode sends as a voice message (re-uploads the file for large file support).
+         */
+        telegramSendAudio(step: TelegramSendAudioStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<TelegramSendAudioStepOutput>>;
+        /**
+         * Send Telegram File
+         *
+         * Send a document/file to a Telegram chat via a bot.
+         */
+        telegramSendFile(step: TelegramSendFileStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<TelegramSendFileStepOutput>>;
+        /**
+         * Send Telegram Image
+         *
+         * Send an image to a Telegram chat via a bot.
+         */
+        telegramSendImage(step: TelegramSendImageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<TelegramSendImageStepOutput>>;
+        /**
+         * Send Telegram Message
+         *
+         * Send a text message to a Telegram chat via a bot.
+         *
+         * ## Usage Notes
+         * - Messages are sent using MarkdownV2 formatting. Special characters are auto-escaped.
+         * - botToken format is "botId:token" — both parts are required.
+         */
+        telegramSendMessage(step: TelegramSendMessageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<TelegramSendMessageStepOutput>>;
+        /**
+         * Send Telegram Video
+         *
+         * Send a video to a Telegram chat via a bot.
+         */
+        telegramSendVideo(step: TelegramSendVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<TelegramSendVideoStepOutput>>;
+        /**
+         * Telegram Set Typing
+         *
+         * Show the "typing..." indicator in a Telegram chat via a bot.
+         *
+         * ## Usage Notes
+         * - The typing indicator automatically expires after a few seconds. Use this right before sending a message for a natural feel.
+         */
+        telegramSetTyping(step: TelegramSetTypingStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<TelegramSetTypingStepOutput>>;
+        /**
+         * Text to Speech
+         *
+         * Generate an audio file from provided text using a speech model.
+         *
+         * ## Usage Notes
+         * - The text field contains the exact words to be spoken (not instructions).
+         * - In foreground mode, the audio is displayed to the user. In background mode, the URL is saved to a variable.
+         */
+        textToSpeech(step: TextToSpeechStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<TextToSpeechStepOutput>>;
+        /**
+         * Transcribe Audio
+         *
+         * Convert an audio file to text using a transcription model.
+         *
+         * ## Usage Notes
+         * - The prompt field provides optional context to improve transcription accuracy (e.g. language, speaker names, domain).
+         */
+        transcribeAudio(step: TranscribeAudioStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<TranscribeAudioStepOutput>>;
+        /**
+         * Trim Media
+         *
+         * Trim an audio or video clip
+         *
+         * ## Usage Notes
+         *
+         */
+        trimMedia(step: TrimMediaStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<TrimMediaStepOutput>>;
+        /**
+         * [Google Calendar] Update Event
+         *
+         * Update an existing event on a Google Calendar. Only specified fields are changed.
+         *
+         * ## Usage Notes
+         * - Requires a Google OAuth connection with Calendar events scope.
+         * - Fetches the existing event first, then applies only the provided updates. Omitted fields are left unchanged.
+         * - Attendees are specified as one email address per line, and replace the entire attendee list.
+         */
+        updateGoogleCalendarEvent(step: UpdateGoogleCalendarEventStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<UpdateGoogleCalendarEventStepOutput>>;
+        /**
+         * [Google] Update Google Doc
+         *
+         * Update the contents of an existing Google Document.
+         *
+         * ## Usage Notes
+         * - operationType controls how content is applied: "addToTop" prepends, "addToBottom" appends, "overwrite" replaces all content.
+         * - textType determines how the text field is interpreted: "plain" for plain text, "html" for HTML markup, "markdown" for Markdown.
+         */
+        updateGoogleDoc(step: UpdateGoogleDocStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<UpdateGoogleDocStepOutput>>;
+        /**
+         * [Google] Update Google Sheet
+         *
+         * Update a Google Spreadsheet with new data.
+         *
+         * ## Usage Notes
+         * - operationType controls how data is written: "addToBottom" appends rows, "overwrite" replaces all data, "range" writes to a specific cell range.
+         * - Data should be provided as CSV in the text field.
+         */
+        updateGoogleSheet(step: UpdateGoogleSheetStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<UpdateGoogleSheetStepOutput>>;
+        /**
+         * Upscale Image
+         *
+         * Increase the resolution of an image using AI upscaling.
+         *
+         * ## Usage Notes
+         * - Output is re-hosted on the CDN as a PNG.
+         */
+        upscaleImage(step: UpscaleImageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<UpscaleImageStepOutput>>;
+        /**
+         * Upscale Video
+         *
+         * Upscale a video file
+         *
+         * ## Usage Notes
+         *
+         */
+        upscaleVideo(step: UpscaleVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<UpscaleVideoStepOutput>>;
+        /**
+         * User Message
+         *
+         * Send a message to an AI model and return the response, or echo a system message.
+         *
+         * ## Usage Notes
+         * - Source "user" sends the message to an LLM and returns the model's response.
+         * - Source "system" echoes the message content directly (no AI call).
+         * - Mode "background" saves the result to a variable. Mode "foreground" streams it to the user (not available in direct execution).
+         * - Structured output (JSON/CSV) can be enforced via structuredOutputType and structuredOutputExample.
+         */
+        userMessage(step: UserMessageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<UserMessageStepOutput>>;
+        /**
+         * Video Face Swap
+         *
+         * Swap faces in a video file
+         *
+         * ## Usage Notes
+         *
+         */
+        videoFaceSwap(step: VideoFaceSwapStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<VideoFaceSwapStepOutput>>;
+        /**
+         * Remove Video Background
+         *
+         * Remove or replace background from a video
+         *
+         * ## Usage Notes
+         *
+         */
+        videoRemoveBackground(step: VideoRemoveBackgroundStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<VideoRemoveBackgroundStepOutput>>;
+        /**
+         * Remove Video Watermark
+         *
+         * Remove a watermark from a video
+         *
+         * ## Usage Notes
+         *
+         */
+        videoRemoveWatermark(step: VideoRemoveWatermarkStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<VideoRemoveWatermarkStepOutput>>;
+        /**
+         * Watermark Image
+         *
+         * Overlay a watermark image onto another image.
+         *
+         * ## Usage Notes
+         * - The watermark is placed at the specified corner with configurable padding and width.
+         */
+        watermarkImage(step: WatermarkImageStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<WatermarkImageStepOutput>>;
+        /**
+         * Watermark Video
+         *
+         * Add an image watermark to a video
+         *
+         * ## Usage Notes
+         *
+         */
+        watermarkVideo(step: WatermarkVideoStepInput, options?: StepExecutionOptions): Promise<StepExecutionResult<WatermarkVideoStepOutput>>;
+    }
+}
+/** @internal Attaches typed step methods to the MindStudioAgent prototype. */
+declare function applyStepMethods(AgentClass: new (...args: any[]) => any): void;
+
+/** An AI model available on MindStudio. */
+interface MindStudioModel {
+    id?: string;
+    /** Display name of the model. */
+    name?: string;
+    /** Full model identifier from the provider. */
+    rawName?: string;
+    /** One of: `llm_chat`, `image_generation`, `video_generation`, `video_analysis`, `text_to_speech`, `vision`, `transcription`. */
+    type?: "llm_chat" | "image_generation" | "video_generation" | "video_analysis" | "text_to_speech" | "vision" | "transcription";
+    publisher?: string;
+    maxTemperature?: number;
+    maxResponseSize?: number;
+    /** Accepted input types for this model (text, imageUrl, videoUrl, etc.). */
+    inputs?: Record<string, unknown>[];
+    contextWindow?: number;
+    tags?: string;
+}
+/** Supported model type categories for filtering. */
+type ModelType = "llm_chat" | "image_generation" | "video_generation" | "video_analysis" | "text_to_speech" | "vision" | "transcription";
+declare module "../client.js" {
+    interface MindStudioAgent {
+        /**
+         * List all available AI models.
+         *
+         * Returns models across all categories (chat, image generation, video, etc.).
+         * Use `listModelsByType()` to filter by category.
+         */
+        listModels(): Promise<{
+            models: MindStudioModel[];
+        }>;
+        /**
+         * List AI models filtered by type.
+         *
+         * @param modelType - The category to filter by (e.g. "llm_chat", "image_generation").
+         */
+        listModelsByType(modelType: ModelType): Promise<{
+            models: MindStudioModel[];
+        }>;
+        /**
+         * List all available connector services (Slack, Google, HubSpot, etc.).
+         */
+        listConnectors(): Promise<{
+            services: Array<{
+                service: Record<string, unknown>;
+                actions: Record<string, unknown>[];
+            }>;
+        }>;
+        /**
+         * Get details for a single connector service.
+         *
+         * @param serviceId - The connector service ID.
+         */
+        getConnector(serviceId: string): Promise<{
+            service: Record<string, unknown>;
+        }>;
+    }
+}
+/** @internal Attaches helper methods to the MindStudioAgent prototype. */
+declare function applyHelperMethods(AgentClass: new (...args: any[]) => any): void;
+
+/**
+ * Client for the MindStudio direct step execution API.
+ *
+ * Create an instance and call typed step methods directly:
+ *
+ * ```ts
+ * const agent = new MindStudioAgent({ apiKey: "your-key" });
+ * const result = await agent.generateImage({ prompt: "a sunset", mode: "background" });
+ * console.log(result.output.imageUrl);
+ * ```
+ *
+ * Authentication is resolved in order:
+ * 1. `apiKey` passed to the constructor
+ * 2. `MINDSTUDIO_API_KEY` environment variable
+ * 3. `CALLBACK_TOKEN` environment variable (auto-set inside MindStudio custom functions)
+ *
+ * Base URL is resolved in order:
+ * 1. `baseUrl` passed to the constructor
+ * 2. `MINDSTUDIO_BASE_URL` environment variable
+ * 3. `REMOTE_HOSTNAME` environment variable (auto-set inside MindStudio custom functions)
+ * 4. `https://v1.mindstudio-api.com` (production default)
+ */
+declare class MindStudioAgent {
+    /** @internal */
+    readonly _httpConfig: HttpClientConfig;
+    constructor(options?: AgentOptions);
+    /**
+     * Execute any step by its type name. This is the low-level method that all
+     * typed step methods delegate to. Use it as an escape hatch for step types
+     * not yet covered by the generated methods.
+     *
+     * ```ts
+     * const result = await agent.executeStep("generateImage", { prompt: "hello", mode: "background" });
+     * ```
+     */
+    executeStep<TOutput = unknown>(stepType: string, step: Record<string, unknown>, options?: StepExecutionOptions): Promise<StepExecutionResult<TOutput>>;
+    /** @internal Used by generated helper methods. */
+    _request<T>(method: 'GET' | 'POST', path: string, body?: unknown): Promise<{
+        data: T;
+        headers: Headers;
+    }>;
+}
+
+/**
+ * Error thrown when a MindStudio API request fails.
+ *
+ * Contains the HTTP status code, an error code from the API,
+ * and any additional details returned in the response body.
+ */
+declare class MindStudioError extends Error {
+    /** Machine-readable error code from the API (e.g. "invalid_step_config"). */
+    readonly code: string;
+    /** HTTP status code of the failed request. */
+    readonly status: number;
+    /** Raw error body from the API, if available. */
+    readonly details?: unknown | undefined;
+    readonly name = "MindStudioError";
+    constructor(message: string, 
+    /** Machine-readable error code from the API (e.g. "invalid_step_config"). */
+    code: string, 
+    /** HTTP status code of the failed request. */
+    status: number, 
+    /** Raw error body from the API, if available. */
+    details?: unknown | undefined);
+}
+
+export { type ActiveCampaignAddNoteStepInput, type ActiveCampaignAddNoteStepOutput, type ActiveCampaignCreateContactStepInput, type ActiveCampaignCreateContactStepOutput, type AddSubtitlesToVideoStepInput, type AddSubtitlesToVideoStepOutput, type AgentOptions, type AirtableCreateUpdateRecordStepInput, type AirtableCreateUpdateRecordStepOutput, type AirtableDeleteRecordStepInput, type AirtableDeleteRecordStepOutput, type AirtableGetRecordStepInput, type AirtableGetRecordStepOutput, type AirtableGetTableRecordsStepInput, type AirtableGetTableRecordsStepOutput, type AnalyzeImageStepInput, type AnalyzeImageStepOutput, type AnalyzeVideoStepInput, type AnalyzeVideoStepOutput, type CaptureThumbnailStepInput, type CaptureThumbnailStepOutput, type CodaCreateUpdatePageStepInput, type CodaCreateUpdatePageStepOutput, type CodaCreateUpdateRowStepInput, type CodaCreateUpdateRowStepOutput, type CodaFindRowStepInput, type CodaFindRowStepOutput, type CodaGetPageStepInput, type CodaGetPageStepOutput, type CodaGetTableRowsStepInput, type CodaGetTableRowsStepOutput, type ConvertPdfToImagesStepInput, type ConvertPdfToImagesStepOutput, type CreateGoogleCalendarEventStepInput, type CreateGoogleCalendarEventStepOutput, type CreateGoogleDocStepInput, type CreateGoogleDocStepOutput, type CreateGoogleSheetStepInput, type CreateGoogleSheetStepOutput, type DeleteGoogleCalendarEventStepInput, type DeleteGoogleCalendarEventStepOutput, type DetectPIIStepInput, type DetectPIIStepOutput, type DownloadVideoStepInput, type DownloadVideoStepOutput, type EnhanceImageGenerationPromptStepInput, type EnhanceImageGenerationPromptStepOutput, type EnhanceVideoGenerationPromptStepInput, type EnhanceVideoGenerationPromptStepOutput, type EnrichPersonStepInput, type EnrichPersonStepOutput, type ExtractAudioFromVideoStepInput, type ExtractAudioFromVideoStepOutput, type ExtractTextStepInput, type ExtractTextStepOutput, type FetchGoogleDocStepInput, type FetchGoogleDocStepOutput, type FetchGoogleSheetStepInput, type FetchGoogleSheetStepOutput, type FetchSlackChannelHistoryStepInput, type FetchSlackChannelHistoryStepOutput, type FetchYoutubeCaptionsStepInput, type FetchYoutubeCaptionsStepOutput, type FetchYoutubeChannelStepInput, type FetchYoutubeChannelStepOutput, type FetchYoutubeCommentsStepInput, type FetchYoutubeCommentsStepOutput, type FetchYoutubeVideoStepInput, type FetchYoutubeVideoStepOutput, type GenerateChartStepInput, type GenerateChartStepOutput, type GenerateImageStepInput, type GenerateImageStepOutput, type GenerateLipsyncStepInput, type GenerateLipsyncStepOutput, type GenerateMusicStepInput, type GenerateMusicStepOutput, type GeneratePdfStepInput, type GeneratePdfStepOutput, type GenerateStaticVideoFromImageStepInput, type GenerateStaticVideoFromImageStepOutput, type GenerateVideoStepInput, type GenerateVideoStepOutput, type GetGoogleCalendarEventStepInput, type GetGoogleCalendarEventStepOutput, type GetMediaMetadataStepInput, type GetMediaMetadataStepOutput, type HttpRequestStepInput, type HttpRequestStepOutput, type HubspotCreateCompanyStepInput, type HubspotCreateCompanyStepOutput, type HubspotCreateContactStepInput, type HubspotCreateContactStepOutput, type HubspotGetCompanyStepInput, type HubspotGetCompanyStepOutput, type HubspotGetContactStepInput, type HubspotGetContactStepOutput, type HunterApiCompanyEnrichmentStepInput, type HunterApiCompanyEnrichmentStepOutput, type HunterApiDomainSearchStepInput, type HunterApiDomainSearchStepOutput, type HunterApiEmailFinderStepInput, type HunterApiEmailFinderStepOutput, type HunterApiEmailVerificationStepInput, type HunterApiEmailVerificationStepOutput, type HunterApiPersonEnrichmentStepInput, type HunterApiPersonEnrichmentStepOutput, type ImageFaceSwapStepInput, type ImageFaceSwapStepOutput, type ImageRemoveWatermarkStepInput, type ImageRemoveWatermarkStepOutput, type InsertVideoClipsStepInput, type InsertVideoClipsStepOutput, type ListGoogleCalendarEventsStepInput, type ListGoogleCalendarEventsStepOutput, type LogicStepInput, type LogicStepOutput, type MakeDotComRunScenarioStepInput, type MakeDotComRunScenarioStepOutput, type MergeAudioStepInput, type MergeAudioStepOutput, type MergeVideosStepInput, type MergeVideosStepOutput, MindStudioAgent, MindStudioError, type MindStudioModel, type MixAudioIntoVideoStepInput, type MixAudioIntoVideoStepOutput, type ModelType, type MuteVideoStepInput, type MuteVideoStepOutput, type N8nRunNodeStepInput, type N8nRunNodeStepOutput, type NotionCreatePageStepInput, type NotionCreatePageStepOutput, type NotionUpdatePageStepInput, type NotionUpdatePageStepOutput, type PeopleSearchStepInput, type PeopleSearchStepOutput, type PostToLinkedInStepInput, type PostToLinkedInStepOutput, type PostToSlackChannelStepInput, type PostToSlackChannelStepOutput, type PostToXStepInput, type PostToXStepOutput, type PostToZapierStepInput, type PostToZapierStepOutput, type QueryDataSourceStepInput, type QueryDataSourceStepOutput, type QueryExternalDatabaseStepInput, type QueryExternalDatabaseStepOutput, type RedactPIIStepInput, type RedactPIIStepOutput, type RemoveBackgroundFromImageStepInput, type RemoveBackgroundFromImageStepOutput, type ResizeVideoStepInput, type ResizeVideoStepOutput, type RunPackagedWorkflowStepInput, type RunPackagedWorkflowStepOutput, type RunWorkflowStepInput, type RunWorkflowStepOutput, type ScrapeFacebookPageStepInput, type ScrapeFacebookPageStepOutput, type ScrapeFacebookPostsStepInput, type ScrapeFacebookPostsStepOutput, type ScrapeInstagramCommentsStepInput, type ScrapeInstagramCommentsStepOutput, type ScrapeInstagramMentionsStepInput, type ScrapeInstagramMentionsStepOutput, type ScrapeInstagramPostsStepInput, type ScrapeInstagramPostsStepOutput, type ScrapeInstagramProfileStepInput, type ScrapeInstagramProfileStepOutput, type ScrapeInstagramReelsStepInput, type ScrapeInstagramReelsStepOutput, type ScrapeLinkedInCompanyStepInput, type ScrapeLinkedInCompanyStepOutput, type ScrapeLinkedInProfileStepInput, type ScrapeLinkedInProfileStepOutput, type ScrapeMetaThreadsProfileStepInput, type ScrapeMetaThreadsProfileStepOutput, type ScrapeUrlStepInput, type ScrapeUrlStepOutput, type ScrapeXPostStepInput, type ScrapeXPostStepOutput, type ScrapeXProfileStepInput, type ScrapeXProfileStepOutput, type SearchGoogleImagesStepInput, type SearchGoogleImagesStepOutput, type SearchGoogleNewsStepInput, type SearchGoogleNewsStepOutput, type SearchGoogleStepInput, type SearchGoogleStepOutput, type SearchGoogleTrendsStepInput, type SearchGoogleTrendsStepOutput, type SearchPerplexityStepInput, type SearchPerplexityStepOutput, type SearchXPostsStepInput, type SearchXPostsStepOutput, type SearchYoutubeStepInput, type SearchYoutubeStepOutput, type SearchYoutubeTrendsStepInput, type SearchYoutubeTrendsStepOutput, type SendEmailStepInput, type SendEmailStepOutput, type SendSMSStepInput, type SendSMSStepOutput, type SetRunTitleStepInput, type SetRunTitleStepOutput, type SetVariableStepInput, type SetVariableStepOutput, type StepExecutionOptions, type StepExecutionResult, type StepInputMap, type StepName, type StepOutputMap, type TelegramSendAudioStepInput, type TelegramSendAudioStepOutput, type TelegramSendFileStepInput, type TelegramSendFileStepOutput, type TelegramSendImageStepInput, type TelegramSendImageStepOutput, type TelegramSendMessageStepInput, type TelegramSendMessageStepOutput, type TelegramSendVideoStepInput, type TelegramSendVideoStepOutput, type TelegramSetTypingStepInput, type TelegramSetTypingStepOutput, type TextToSpeechStepInput, type TextToSpeechStepOutput, type TranscribeAudioStepInput, type TranscribeAudioStepOutput, type TrimMediaStepInput, type TrimMediaStepOutput, type UpdateGoogleCalendarEventStepInput, type UpdateGoogleCalendarEventStepOutput, type UpdateGoogleDocStepInput, type UpdateGoogleDocStepOutput, type UpdateGoogleSheetStepInput, type UpdateGoogleSheetStepOutput, type UpscaleImageStepInput, type UpscaleImageStepOutput, type UpscaleVideoStepInput, type UpscaleVideoStepOutput, type UserMessageStepInput, type UserMessageStepOutput, type VideoFaceSwapStepInput, type VideoFaceSwapStepOutput, type VideoRemoveBackgroundStepInput, type VideoRemoveBackgroundStepOutput, type VideoRemoveWatermarkStepInput, type VideoRemoveWatermarkStepOutput, type WatermarkImageStepInput, type WatermarkImageStepOutput, type WatermarkVideoStepInput, type WatermarkVideoStepOutput, applyHelperMethods, applyStepMethods };