import { ButtonPassThroughOptionType } from 'primevue';
import { Component } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComponentPublicInstance } from 'vue';
import { ComputedOptions } from 'vue';
import { DebuggerEvent } from 'vue';
import { default as default_2 } from '../components/dialog/content/LoadWorkflowWarning.vue';
import { default as default_3 } from '../components/dialog/content/MissingModelsWarning.vue';
import { default as default_4 } from '../components/dialog/content/ExecutionErrorDialogContent.vue';
import { default as default_5 } from '../components/templates/TemplateWorkflowsContent.vue';
import { default as default_6 } from '../components/dialog/content/IssueReportDialogContent.vue';
import { default as default_7 } from '../components/dialog/content/manager/ManagerDialogContent.vue';
import { default as default_8 } from '../components/dialog/content/ManagerProgressDialogContent.vue';
import { DialogPassThroughMethodOptions } from 'primevue';
import { DialogPassThroughOptionType } from 'primevue';
import { DialogSharedPassThroughMethodOptions } from 'primevue';
import { Directive } from 'vue';
import { EmbeddingsResponse } from '../schemas/apiSchema';
import { ExecutedWsMessage } from '../schemas/apiSchema';
import { ExecutingWsMessage } from '../schemas/apiSchema';
import { ExecutionCachedWsMessage } from '../schemas/apiSchema';
import { ExecutionErrorWsMessage } from '../schemas/apiSchema';
import { ExecutionInterruptedWsMessage } from '../schemas/apiSchema';
import { ExecutionStartWsMessage } from '../schemas/apiSchema';
import { ExecutionSuccessWsMessage } from '../schemas/apiSchema';
import { ExtensionsResponse } from '../schemas/apiSchema';
import { FunctionalComponent } from 'vue';
import { HistoryTaskItem } from '../schemas/apiSchema';
import { IntlDateTimeFormat } from 'vue-i18n';
import { IntlNumberFormat } from 'vue-i18n';
import { ISerialisedGraph } from '@comfyorg/litegraph';
import { IWidget } from '@comfyorg/litegraph';
import { LGraph } from '@comfyorg/litegraph';
import { LGraphCanvas } from '@comfyorg/litegraph';
import { LGraphNode } from '@comfyorg/litegraph';
import { LinkedModifiers } from 'vue-i18n';
import { Locale } from 'vue-i18n';
import { LocaleMessage } from '@intlify/core-base';
import { LocaleMessages } from 'vue-i18n';
import { LogsRawResponse } from '../schemas/apiSchema';
import { LogsWsMessage } from '../schemas/apiSchema';
import { LooseRequired } from '@vue/shared';
import { MessageResolver } from 'vue-i18n';
import { MethodOptions } from 'vue';
import { MissingHandler } from 'vue-i18n';
import { NavigationGuard } from 'vue-router';
import { NavigationGuardWithThis } from 'vue-router';
import { PendingTaskItem } from '../schemas/apiSchema';
import { PluralizationRules } from '@intlify/core-base';
import { Positionable } from '@comfyorg/litegraph/dist/interfaces';
import { PostTranslationHandler } from 'vue-i18n';
import { ProgressWsMessage } from '../schemas/apiSchema';
import { PromptResponse } from '../schemas/apiSchema';
import { RenderFunction } from 'vue';
import { RunningTaskItem } from '../schemas/apiSchema';
import { Settings } from '../schemas/apiSchema';
import { Settings as Settings_2 } from '../../schemas/apiSchema';
import { Settings as Settings_3 } from '../../../schemas/apiSchema';
import { Slot } from 'vue';
import { StatusWsMessage } from '../schemas/apiSchema';
import { StatusWsMessageStatus } from '../schemas/apiSchema';
import { SystemStats } from '../schemas/apiSchema';
import { TransitionProps } from 'vue';
import { TypesConfig } from 'vue-router';
import { User } from '../schemas/apiSchema';
import { UserDataFullInfo } from '../schemas/apiSchema';
import { Vector2 } from '@comfyorg/litegraph';
import { VNode } from 'vue';
import { VueMessageType } from 'vue-i18n';
import { WarnHtmlInMessageLevel } from 'vue-i18n';
import { WatchCallback } from 'vue';
import { WatchOptions } from 'vue';
import { z } from 'zod';

declare interface AboutPageBadge {
    label: string;
    url: string;
    icon: string;
}

/** Dictionary of all api calls */
declare interface ApiCalls extends BackendApiCalls, FrontendApiCalls {
}

/** Dictionary of API events: `[name]: CustomEvent<Type>` */
declare type ApiEvents = AsCustomEvents<ApiEventTypes>;

/** Dictionary of types used in the detail for a custom event */
declare type ApiEventTypes = ApiToEventType<ApiCalls>;

/** Handles differing event and API signatures. */
declare type ApiToEventType<T = ApiCalls> = {
    [K in keyof T]: K extends 'status' ? StatusWsMessageStatus : K extends 'executing' ? NodeId : T[K];
};

/** Wraps all properties in {@link CustomEvent}. */
declare type AsCustomEvents<T> = {
    readonly [K in keyof T]: CustomEvent<T[K]>;
};

/** Dictionary of calls originating from ComfyUI core */
declare interface BackendApiCalls {
    progress: ProgressWsMessage;
    executing: ExecutingWsMessage;
    executed: ExecutedWsMessage;
    status: StatusWsMessage;
    execution_start: ExecutionStartWsMessage;
    execution_success: ExecutionSuccessWsMessage;
    execution_error: ExecutionErrorWsMessage;
    execution_interrupted: ExecutionInterruptedWsMessage;
    execution_cached: ExecutionCachedWsMessage;
    logs: LogsWsMessage;
    /** Mr Blob Preview, I presume? */
    b_preview: Blob;
}

declare interface BaseBottomPanelExtension {
    id: string;
    title: string;
}

declare interface BaseSidebarTabExtension {
    id: string;
    title: string;
    icon?: string;
    iconBadge?: string | (() => string | null);
    tooltip?: string;
}

declare type BottomPanelExtension = VueBottomPanelExtension | CustomBottomPanelExtension;

declare class ChangeTracker {
    /**
     * The workflow that this change tracker is tracking
     */
    workflow: ComfyWorkflow;
    /**
     * The initial state of the workflow
     */
    initialState: ComfyWorkflowJSON;
    static MAX_HISTORY: number;
    /**
     * The active state of the workflow.
     */
    activeState: ComfyWorkflowJSON;
    undoQueue: ComfyWorkflowJSON[];
    redoQueue: ComfyWorkflowJSON[];
    changeCount: number;
    /**
     * Whether the redo/undo restoring is in progress.
     */
    private restoringState;
    ds?: {
        scale: number;
        offset: [number, number];
    };
    nodeOutputs?: Record<string, any>;
    static app?: ComfyApp;
    get app(): ComfyApp;
    constructor(
    /**
     * The workflow that this change tracker is tracking
     */
    workflow: ComfyWorkflow, 
    /**
     * The initial state of the workflow
     */
    initialState: ComfyWorkflowJSON);
    /**
     * Save the current state as the initial state.
     */
    reset(state?: ComfyWorkflowJSON): void;
    store(): void;
    restore(): void;
    updateModified(): void;
    checkState(): void;
    updateState(source: ComfyWorkflowJSON[], target: ComfyWorkflowJSON[]): Promise<void>;
    undo(): Promise<void>;
    redo(): Promise<void>;
    undoRedo(e: KeyboardEvent): Promise<true | undefined>;
    beforeChange(): void;
    afterChange(): void;
    static init(app: ComfyApp): void;
    static bindInput(_app: ComfyApp, activeEl: Element | null): boolean;
    static graphEqual(a: ComfyWorkflowJSON, b: ComfyWorkflowJSON): boolean;
    private static graphDiff;
}

declare type ClassList = string | string[] | Record<string, boolean>;

declare type Clipspace = {
    widgets?: Pick<IWidget, 'type' | 'name' | 'value'>[] | null;
    imgs?: HTMLImageElement[] | null;
    original_imgs?: HTMLImageElement[] | null;
    images?: any[] | null;
    selectedIndex: number;
    img_paste_mode: string;
};

/** EventTarget typing has no generic capability. */
export declare interface ComfyApi extends EventTarget {
    addEventListener<TEvent extends keyof ApiEvents>(type: TEvent, callback: ((event: ApiEvents[TEvent]) => void) | null, options?: AddEventListenerOptions | boolean): void;
    removeEventListener<TEvent extends keyof ApiEvents>(type: TEvent, callback: ((event: ApiEvents[TEvent]) => void) | null, options?: EventListenerOptions | boolean): void;
}

export declare class ComfyApi extends EventTarget {
    #private;
    api_host: string;
    api_base: string;
    /**
     * The client id from the initial session storage.
     */
    initialClientId: string | null;
    /**
     * The current client id from websocket status updates.
     */
    clientId?: string;
    /**
     * The current user id.
     */
    user: string;
    socket: WebSocket | null;
    reportedUnknownMessageTypes: Set<string>;
    constructor();
    internalURL(route: string): string;
    apiURL(route: string): string;
    fileURL(route: string): string;
    fetchApi(route: string, options?: RequestInit): Promise<Response>;
    /**
     * Dispatches a custom event.
     * Provides type safety for the contravariance issue with EventTarget (last checked TS 5.6).
     * @param type The type of event to emit
     * @param detail The detail property used for a custom event ({@link CustomEventInit.detail})
     */
    dispatchCustomEvent<T extends SimpleApiEvents>(type: T): boolean;
    dispatchCustomEvent<T extends ComplexApiEvents>(type: T, detail: ApiEventTypes[T] | null): boolean;
    /** @deprecated Use {@link dispatchCustomEvent}. */
    dispatchEvent(event: never): boolean;
    /**
     * Initialises sockets and realtime updates
     */
    init(): void;
    /**
     * Gets a list of extension urls
     */
    getExtensions(): Promise<ExtensionsResponse>;
    /**
     * Gets the available workflow templates from custom nodes.
     * @returns A map of custom_node names and associated template workflow names.
     */
    getWorkflowTemplates(): Promise<{
        [customNodesName: string]: string[];
    }>;
    /**
     * Gets the index of core workflow templates.
     */
    getCoreWorkflowTemplates(): Promise<WorkflowTemplates[]>;
    /**
     * Gets a list of embedding names
     */
    getEmbeddings(): Promise<EmbeddingsResponse>;
    /**
     * Loads node object definitions for the graph
     * @returns The node definitions
     */
    getNodeDefs({ validate }?: {
        validate?: boolean;
    }): Promise<Record<string, ComfyNodeDef>>;
    /**
     *
     * @param {number} number The index at which to queue the prompt, passing -1 will insert the prompt at the front of the queue
     * @param {object} prompt The prompt data to queue
     */
    queuePrompt(number: number, { output, workflow }: {
        output: Record<number, any>;
        workflow: ComfyWorkflowJSON;
    }): Promise<PromptResponse>;
    /**
     * Gets a list of model folder keys (eg ['checkpoints', 'loras', ...])
     * @returns The list of model folder keys
     */
    getModelFolders(): Promise<{
        name: string;
        folders: string[];
    }[]>;
    /**
     * Gets a list of models in the specified folder
     * @param {string} folder The folder to list models from, such as 'checkpoints'
     * @returns The list of model filenames within the specified folder
     */
    getModels(folder: string): Promise<{
        name: string;
        pathIndex: number;
    }[]>;
    /**
     * Gets the metadata for a model
     * @param {string} folder The folder containing the model
     * @param {string} model The model to get metadata for
     * @returns The metadata for the model
     */
    viewMetadata(folder: string, model: string): Promise<any>;
    /**
     * Loads a list of items (queue or history)
     * @param {string} type The type of items to load, queue or history
     * @returns The items of the specified type grouped by their status
     */
    getItems(type: 'queue' | 'history'): Promise<{
        Running: RunningTaskItem[];
        Pending: PendingTaskItem[];
    } | {
        History: HistoryTaskItem[];
    }>;
    /**
     * Gets the current state of the queue
     * @returns The currently running and queued items
     */
    getQueue(): Promise<{
        Running: RunningTaskItem[];
        Pending: PendingTaskItem[];
    }>;
    /**
     * Gets the prompt execution history
     * @returns Prompt history including node outputs
     */
    getHistory(max_items?: number): Promise<{
        History: HistoryTaskItem[];
    }>;
    /**
     * Gets system & device stats
     * @returns System stats such as python version, OS, per device info
     */
    getSystemStats(): Promise<SystemStats>;
    /**
     * Deletes an item from the specified list
     * @param {string} type The type of item to delete, queue or history
     * @param {number} id The id of the item to delete
     */
    deleteItem(type: string, id: string): Promise<void>;
    /**
     * Clears the specified list
     * @param {string} type The type of list to clear, queue or history
     */
    clearItems(type: string): Promise<void>;
    /**
     * Interrupts the execution of the running prompt
     */
    interrupt(): Promise<void>;
    /**
     * Gets user configuration data and where data should be stored
     */
    getUserConfig(): Promise<User>;
    /**
     * Creates a new user
     * @param { string } username
     * @returns The fetch response
     */
    createUser(username: string): Promise<Response>;
    /**
     * Gets all setting values for the current user
     * @returns { Promise<string, unknown> } A dictionary of id -> value
     */
    getSettings(): Promise<Settings>;
    /**
     * Gets a setting for the current user
     * @param { string } id The id of the setting to fetch
     * @returns { Promise<unknown> } The setting value
     */
    getSetting(id: keyof Settings): Promise<Settings[keyof Settings]>;
    /**
     * Stores a dictionary of settings for the current user
     */
    storeSettings(settings: Settings): Promise<Response>;
    /**
     * Stores a setting for the current user
     */
    storeSetting(id: keyof Settings, value: Settings[keyof Settings]): Promise<Response>;
    /**
     * Gets a user data file for the current user
     */
    getUserData(file: string, options?: RequestInit): Promise<Response>;
    /**
     * Stores a user data file for the current user
     * @param { string } file The name of the userdata file to save
     * @param { unknown } data The data to save to the file
     * @param { RequestInit & { stringify?: boolean, throwOnError?: boolean } } [options]
     * @returns { Promise<Response> }
     */
    storeUserData(file: string, data: any, options?: RequestInit & {
        overwrite?: boolean;
        stringify?: boolean;
        throwOnError?: boolean;
        full_info?: boolean;
    }): Promise<Response>;
    /**
     * Deletes a user data file for the current user
     * @param { string } file The name of the userdata file to delete
     */
    deleteUserData(file: string): Promise<Response>;
    /**
     * Move a user data file for the current user
     * @param { string } source The userdata file to move
     * @param { string } dest The destination for the file
     */
    moveUserData(source: string, dest: string, options?: {
        overwrite: boolean;
    }): Promise<Response>;
    /**
     * @overload@overload
     * Lists user data files for the current user
     * @param { string } dir The directory in which to list files
     * @param { boolean } [recurse] If the listing should be recursive
     * @param { true } [split] If the paths should be split based on the os path separator
     * @returns { Promise<string[][]> } The list of split file paths in the format [fullPath, ...splitPath]
     */
    /**
     * @overload@overload
     * Lists user data files for the current user
     * @param { string } dir The directory in which to list files
     * @param { boolean } [recurse] If the listing should be recursive
     * @param { false | undefined } [split] If the paths should be split based on the os path separator
     * @returns { Promise<string[]> } The list of files
     */
    listUserData(dir: string, recurse: boolean, split?: true): Promise<string[][]>;
    listUserData(dir: string, recurse: boolean, split?: false): Promise<string[]>;
    listUserDataFullInfo(dir: string): Promise<UserDataFullInfo[]>;
    getLogs(): Promise<string>;
    getRawLogs(): Promise<LogsRawResponse>;
    subscribeLogs(enabled: boolean): Promise<void>;
    getFolderPaths(): Promise<Record<string, string[]>>;
    /**
     * Gets the custom nodes i18n data from the server.
     *
     * @returns The custom nodes i18n data
     */
    getCustomNodesI18n(): Promise<Record<string, any>>;
}

declare type ComfyApiWorkflow = z.infer<typeof zComfyApiWorkflow>;

export declare class ComfyApp {
    #private;
    /**
     * Content Clipboard
     * @type {serialized node object}
         */
     static clipspace: Clipspace | null;
     static clipspace_invalidate_handler: (() => void) | null;
     static open_maskeditor: null;
     static clipspace_return_node: null;
     vueAppReady: boolean;
     api: ComfyApi;
     ui: ComfyUI;
     extensionManager: ExtensionManager;
     _nodeOutputs: Record<string, any>;
     nodePreviewImages: Record<string, string[]>;
     graph: LGraph;
     canvas: LGraphCanvas;
     dragOverNode: LGraphNode | null;
     canvasEl: HTMLCanvasElement;
     lastNodeErrors: any[] | null;
     /** @type {ExecutionErrorWsMessage} */
     lastExecutionError: {
         node_id?: NodeId;
     } | null;
     configuringGraph: boolean;
     ctx: CanvasRenderingContext2D;
     bodyTop: HTMLElement;
     bodyLeft: HTMLElement;
     bodyRight: HTMLElement;
     bodyBottom: HTMLElement;
     canvasContainer: HTMLElement;
     menu: ComfyAppMenu;
     bypassBgColor: string;
     openClipspace: () => void;
     /**
      * @deprecated Use useExecutionStore().executingNodeId instead
      */
     get runningNodeId(): string | null;
     /**
      * @deprecated Use useWorkspaceStore().shiftDown instead
      */
     get shiftDown(): boolean;
     /**
      * @deprecated Use useWidgetStore().widgets instead
      */
     get widgets(): Record<string, ComfyWidgetConstructor>;
     /**
      * @deprecated storageLocation is always 'server' since
      * https://github.com/comfyanonymous/ComfyUI/commit/53c8a99e6c00b5e20425100f6680cd9ea2652218
      */
     get storageLocation(): string;
     /**
      * @deprecated storage migration is no longer needed.
      */
     get isNewUserSession(): boolean;
     /**
      * @deprecated Use useExtensionStore().extensions instead
      */
     get extensions(): ComfyExtension[];
     /**
      * The progress on the current executing node, if the node reports any.
      * @deprecated Use useExecutionStore().executingNodeProgress instead
      */
     get progress(): {
         value: number;
         max: number;
         prompt_id: string;
         node: string | number;
     } | null;
     /**
      * @deprecated Use {@link isImageNode} from @/utils/litegraphUtil instead
      */
     static isImageNode(node: LGraphNode): node is LGraphNode & {
         imgs: HTMLImageElement[] | undefined;
     };
     /**
      * Resets the canvas view to the default
      * @deprecated Use {@link useLitegraphService().resetView} instead
      */
     resetView(): void;
     constructor();
     get nodeOutputs(): Record<string, any>;
     set nodeOutputs(value: Record<string, any>);
     getPreviewFormatParam(): string;
     getRandParam(): string;
     static onClipspaceEditorSave(): void;
     static onClipspaceEditorClosed(): void;
     static copyToClipspace(node: any): void;
     static pasteFromClipspace(node: LGraphNode): void;
     /**
      * Set up the app on the page
      */
     setup(canvasEl: HTMLCanvasElement): Promise<void>;
     resizeCanvas(): void;
     private updateVueAppNodeDefs;
     /**
      * Registers nodes with the graph
      */
     registerNodes(): Promise<void>;
     registerNodeDef(nodeId: string, nodeDef: ComfyNodeDef): Promise<void>;
     registerNodesFromDefs(defs: Record<string, ComfyNodeDef>): Promise<void>;
     loadTemplateData(templateData: any): void;
     loadGraphData(graphData?: ComfyWorkflowJSON, clean?: boolean, restore_view?: boolean, workflow?: string | null | ComfyWorkflow, { showMissingNodesDialog, showMissingModelsDialog }?: {
         showMissingNodesDialog?: boolean | undefined;
         showMissingModelsDialog?: boolean | undefined;
     }): Promise<void>;
     /**
      * Serializes a graph using preferred user settings.
      * @param graph The litegraph to serialize.
      * @returns A serialized graph (aka workflow) with preferred user settings.
      */
     serializeGraph(graph?: LGraph): ISerialisedGraph;
     graphToPrompt(graph?: LGraph): Promise<{
         workflow: ComfyWorkflowJSON;
         output: ComfyApiWorkflow;
     }>;
     queuePrompt(number: number, batchCount?: number): Promise<boolean>;
     showErrorOnFileLoad(file: any): void;
     /**
      * Loads workflow data from the specified file
      * @param {File} file
      */
     handleFile(file: any): Promise<void>;
     isApiJson(data: any): boolean;
     loadApiJson(apiData: any, fileName: string): void;
     /**
      * Registers a Comfy web extension with the app
      * @param {ComfyExtension} extension
      * @deprecated Use useExtensionService().registerExtension instead
      */
     registerExtension(extension: ComfyExtension): void;
     /**
      * Refresh combo list on whole nodes
      */
     refreshComboInNodes(): Promise<void>;
     /**
      * Frees memory allocated to image preview blobs for a specific node, by revoking the URLs associated with them.
      * @param nodeId ID of the node to revoke all preview images of
      */
     revokePreviews(nodeId: NodeId): void;
     /**
      * Clean current state
      */
     clean(): void;
     clientPosToCanvasPos(pos: Vector2): Vector2;
     canvasPosToClientPos(pos: Vector2): Vector2;
    }

    declare class ComfyAppMenu {
        app: ComfyApp;
        actionsGroup: ComfyButtonGroup;
        settingsGroup: ComfyButtonGroup;
        viewGroup: ComfyButtonGroup;
        element: HTMLElement;
        constructor(app: ComfyApp);
    }

    declare class ComfyButton implements ComfyComponent<HTMLElement> {
        #private;
        isOver: boolean;
        iconElement: HTMLElement;
        contentElement: HTMLSpanElement;
        popup: ComfyPopup;
        element: HTMLElement;
        overIcon: string;
        iconSize: number;
        content: string | HTMLElement;
        icon: string;
        tooltip: string;
        classList: ClassList;
        hidden: boolean;
        enabled: boolean;
        action: (e: Event, btn: ComfyButton) => void;
        constructor({ icon, overIcon, iconSize, content, tooltip, action, classList, visibilitySetting, app, enabled }: ComfyButtonProps);
        updateIcon: () => string;
        updateClasses: () => void;
        withPopup(popup: ComfyPopup, mode?: 'click' | 'hover'): this;
    }

    declare class ComfyButtonGroup {
        element: HTMLElement;
        buttons: (HTMLElement | ComfyButton)[];
        constructor(...buttons: (HTMLElement | ComfyButton)[]);
        insert(button: ComfyButton, index: number): void;
        append(button: ComfyButton): void;
        remove(indexOrButton: ComfyButton | number): (HTMLElement | ComfyButton)[] | undefined;
        update(): void;
    }

    declare type ComfyButtonProps = {
        icon?: string;
        overIcon?: string;
        iconSize?: number;
        content?: string | HTMLElement;
        tooltip?: string;
        enabled?: boolean;
        action?: (e: Event, btn: ComfyButton) => void;
        classList?: ClassList;
        visibilitySetting?: {
            id: keyof Settings_3;
            showValue: boolean;
        };
        app?: ComfyApp;
    };

    declare interface ComfyCommand {
        id: string;
        function: () => void | Promise<void>;
        label?: string | (() => string);
        icon?: string | (() => string);
        tooltip?: string | (() => string);
        /** Menubar item label, if different from command label */
        menubarLabel?: string | (() => string);
        versionAdded?: string;
        /** If non-nullish, this command will prompt for confirmation. */
        confirmation?: string;
    }

    declare interface ComfyComponent<T extends HTMLElement = HTMLElement> {
        element: T;
    }

    declare class ComfyDialog<T extends HTMLElement = HTMLElement> extends EventTarget {
        #private;
        element: T;
        textElement: HTMLElement;
        constructor(type?: string, buttons?: null);
        createButtons(): HTMLButtonElement[];
        close(): void;
        show(html: any): void;
    }

    export declare interface ComfyExtension {
        /**
         * The name of the extension
         */
        name: string;
        /**
         * The commands defined by the extension
         */
        commands?: ComfyCommand[];
        /**
         * The keybindings defined by the extension
         */
        keybindings?: Keybinding[];
        /**
         * Menu commands to add to the menu bar
         */
        menuCommands?: MenuCommandGroup[];
        /**
         * Settings to add to the settings menu
         */
        settings?: SettingParams[];
        /**
         * Bottom panel tabs to add to the bottom panel
         */
        bottomPanelTabs?: BottomPanelExtension[];
        /**
         * Badges to add to the about page
         */
        aboutPageBadges?: AboutPageBadge[];
        /**
         * Allows any initialisation, e.g. loading resources. Called after the canvas is created but before nodes are added
         * @param app The ComfyUI app instance
         */
        init?(app: ComfyApp): Promise<void> | void;
        /**
         * Allows any additional setup, called after the application is fully set up and running
         * @param app The ComfyUI app instance
         */
        setup?(app: ComfyApp): Promise<void> | void;
        /**
         * Called before nodes are registered with the graph
         * @param defs The collection of node definitions, add custom ones or edit existing ones
         * @param app The ComfyUI app instance
         */
        addCustomNodeDefs?(defs: Record<string, ComfyNodeDef>, app: ComfyApp): Promise<void> | void;
        /**
         * Allows the extension to add custom widgets
         * @param app The ComfyUI app instance
         * @returns An array of {[widget name]: widget data}
         */
        getCustomWidgets?(app: ComfyApp): Promise<Widgets> | Widgets;
        /**
         * Allows the extension to add additional commands to the selection toolbox
         * @param selectedItem The selected item on the canvas
         * @returns An array of command ids to add to the selection toolbox
         */
        getSelectionToolboxCommands?(selectedItem: Positionable): string[];
        /**
         * Allows the extension to add additional handling to the node before it is registered with **LGraph**
         * @param nodeType The node class (not an instance)
         * @param nodeData The original node object info config object
         * @param app The ComfyUI app instance
         */
        beforeRegisterNodeDef?(nodeType: typeof LGraphNode, nodeData: ComfyNodeDef, app: ComfyApp): Promise<void> | void;
        /**
         * Allows the extension to modify the node definitions before they are used in the Vue app
         * Modifications is expected to be made in place.
         *
         * @param defs The node definitions
         * @param app The ComfyUI app instance
         */
        beforeRegisterVueAppNodeDefs?(defs: ComfyNodeDef[], app: ComfyApp): void;
        /**
         * Allows the extension to register additional nodes with LGraph after standard nodes are added.
         * Custom node classes should extend **LGraphNode**.
         *
         * @param app The ComfyUI app instance
         */
        registerCustomNodes?(app: ComfyApp): Promise<void> | void;
        /**
         * Allows the extension to modify a node that has been reloaded onto the graph.
         * If you break something in the backend and want to patch workflows in the frontend
         * This is the place to do this
         * @param node The node that has been loaded
         * @param app The ComfyUI app instance
         */
        loadedGraphNode?(node: LGraphNode, app: ComfyApp): void;
        /**
         * Allows the extension to run code after the constructor of the node
         * @param node The node that has been created
         * @param app The ComfyUI app instance
         */
        nodeCreated?(node: LGraphNode, app: ComfyApp): void;
        /**
         * Allows the extension to modify the graph data before it is configured.
         * @param graphData The graph data
         * @param missingNodeTypes The missing node types
         */
        beforeConfigureGraph?(graphData: ComfyWorkflowJSON, missingNodeTypes: MissingNodeType[]): Promise<void> | void;
        /**
         * Allows the extension to run code after the graph is configured.
         * @param missingNodeTypes The missing node types
         */
        afterConfigureGraph?(missingNodeTypes: MissingNodeType[]): Promise<void> | void;
        [key: string]: any;
    }

    declare class ComfyList {
        #private;
        element: HTMLDivElement;
        button?: HTMLButtonElement;
        constructor(text: any, type?: any, reverse?: any);
        get visible(): boolean;
        load(): Promise<void>;
        update(): Promise<void>;
        show(): Promise<void>;
        hide(): void;
        toggle(): boolean;
    }

    declare type ComfyNodeDef = z.infer<typeof zComfyNodeDef>;

    declare class ComfyPopup extends EventTarget {
        #private;
        element: HTMLElement;
        open: boolean;
        children: HTMLElement[];
        target: HTMLElement;
        ignoreTarget: boolean;
        container: HTMLElement;
        position: string;
        closeOnEscape: boolean;
        horizontal: string;
        classList: ClassList;
        constructor({ target, container, classList, ignoreTarget, closeOnEscape, position, horizontal }: {
            target: HTMLElement;
            container?: HTMLElement;
            classList?: ClassList;
            ignoreTarget?: boolean;
            closeOnEscape?: boolean;
            position?: 'absolute' | 'relative';
            horizontal?: 'left' | 'right';
        }, ...children: HTMLElement[]);
        toggle(): void;
        update: () => void;
    }

    declare class ComfySettingsDialog extends ComfyDialog<HTMLDialogElement> {
        app: ComfyApp;
        constructor(app: ComfyApp);
        dispatchChange<T>(id: string, value: T, oldValue?: T): void;
        /**
         * @deprecated Use `settingStore.settingValues` instead.
         */
        get settingsValues(): Record<string, any>;
        /**
         * @deprecated Use `settingStore.settingsById` instead.
         */
        get settingsLookup(): Record<string, SettingParams>;
        /**
         * @deprecated Use `settingStore.settingsById` instead.
         */
        get settingsParamLookup(): Record<string, SettingParams>;
        /**
         * @deprecated Use `settingStore.get` instead.
         */
        getSettingValue<K extends keyof Settings_2>(id: K, defaultValue?: Settings_2[K]): Settings_2[K];
        /**
         * @deprecated Use `settingStore.getDefaultValue` instead.
         */
        getSettingDefaultValue<K extends keyof Settings_2>(id: K): Settings_2[K];
        /**
         * @deprecated Use `settingStore.set` instead.
         */
        setSettingValueAsync<K extends keyof Settings_2>(id: K, value: Settings_2[K]): Promise<void>;
        /**
         * @deprecated Use `settingStore.set` instead.
         */
        setSettingValue<K extends keyof Settings_2>(id: K, value: Settings_2[K]): void;
        /**
         * @deprecated Deprecated for external callers/extensions. Use
         * `ComfyExtension.settings` field instead.
         *
         * Example:
         * ```ts
         * app.registerExtension({
         *   name: 'My Extension',
         *   settings: [
         *     {
         *       id: 'My.Setting',
         *       name: 'My Setting',
         *       type: 'text',
         *       defaultValue: 'Hello, world!'
         *     }
         *   ]
         * })
         * ```
         */
        addSetting(params: SettingParams): {
            value: any;
        };
    }

    declare class ComfyUI {
        app: ComfyApp;
        dialog: ComfyDialog;
        settings: ComfySettingsDialog;
        batchCount: number;
        lastQueueSize: number;
        queue: ComfyList;
        history: ComfyList;
        autoQueueMode: string;
        graphHasChanged: boolean;
        autoQueueEnabled: boolean;
        menuContainer: HTMLDivElement;
        queueSize: Element;
        restoreMenuPosition: () => void;
        loadFile: () => void;
        constructor(app: any);
        setup(containerElement: HTMLElement): void;
        setStatus(status: StatusWsMessageStatus | null): void;
    }

    declare type ComfyWidgetConstructor = (node: LGraphNode, inputName: string, inputData: InputSpec, app: ComfyApp, widgetName?: string) => {
        widget: IWidget;
        minWidth?: number;
        minHeight?: number;
    };

    declare class ComfyWorkflow extends UserFile {
        static readonly basePath = "workflows/";
        /**
         * The change tracker for the workflow. Non-reactive raw object.
         */
        changeTracker: ChangeTracker | null;
        /**
         * Whether the workflow has been modified comparing to the initial state.
         */
        private _isModified;
        /**
         * @param options The path, modified, and size of the workflow.
         * Note: path is the full path, including the 'workflows/' prefix.
         */
        constructor(options: {
            path: string;
            modified: number;
            size: number;
        });
        get key(): string;
        get activeState(): ComfyWorkflowJSON | null;
        get initialState(): ComfyWorkflowJSON | null;
        get isLoaded(): boolean;
        get isModified(): boolean;
        set isModified(value: boolean);
        /**
         * Load the workflow content from remote storage. Directly returns the loaded
         * workflow if the content is already loaded.
         *
         * @param force Whether to force loading the content even if it is already loaded.
         * @returns this
         */
        load({ force }?: {
            force?: boolean;
        }): Promise<LoadedComfyWorkflow>;
        unload(): void;
        save(): Promise<UserFile>;
        /**
         * Save the workflow as a new file.
         * @param path The path to save the workflow to. Note: with 'workflows/' prefix.
         * @returns this
         */
        saveAs(path: string): Promise<UserFile>;
    }

    declare type ComfyWorkflowJSON = z.infer<typeof zComfyWorkflow | typeof zComfyWorkflow1>;

    declare interface CommandManager {
        commands: ComfyCommand[];
        execute(command: string, errorHandler?: (error: any) => void): void;
    }

    /** Keys (names) of API events that pass a {@link CustomEvent} `detail` object. */
    declare type ComplexApiEvents = keyof NeverNever<ApiEventTypes>;

    declare type ConfirmationDialogType = 'default' | 'overwrite' | 'delete' | 'dirtyClose' | 'reinstall';

    declare type CustomBottomPanelExtension = BaseBottomPanelExtension & CustomExtension;

    declare interface CustomExtension {
        id: string;
        type: 'custom';
        render: (container: HTMLElement) => void;
        destroy?: () => void;
    }

    declare type CustomSidebarTabExtension = BaseSidebarTabExtension & CustomExtension;

    declare interface ExtensionManager {
        registerSidebarTab(tab: SidebarTabExtension): void;
        unregisterSidebarTab(id: string): void;
        getSidebarTabs(): SidebarTabExtension[];
        toast: ToastManager;
        dialog: ReturnType<typeof useDialogService>;
        command: CommandManager;
        setting: {
            get: (id: string) => any;
            set: (id: string, value: any) => void;
        };
    }

    /**
     * The base form item for rendering in a form.
     */
    declare interface FormItem {
        name: string;
        type: SettingInputType | SettingCustomRenderer;
        tooltip?: string;
        attrs?: Record<string, any>;
        options?: Array<string | SettingOption>;
    }

    /** Dictionary of Frontend-generated API calls */
    declare interface FrontendApiCalls {
        graphChanged: ComfyWorkflowJSON;
        promptQueued: {
            number: number;
            batchCount: number;
        };
        graphCleared: never;
        reconnecting: never;
        reconnected: never;
    }

    declare type InputSpec = z.infer<typeof zInputSpec>;

    declare type Keybinding = z.infer<typeof zKeybinding>;

    declare interface LoadedComfyWorkflow extends ComfyWorkflow {
        isLoaded: true;
        originalContent: string;
        content: string;
        changeTracker: ChangeTracker;
        initialState: ComfyWorkflowJSON;
        activeState: ComfyWorkflowJSON;
    }

    declare interface LoadedUserFile extends UserFile {
        isLoaded: true;
        originalContent: string;
        content: string;
    }

    declare type MenuCommandGroup = {
        /**
         * The path to the menu group.
         */
        path: string[];
        /**
         * Command ids.
         * Note: Commands must be defined in `commands` array in the extension.
         */
        commands: string[];
    };

    declare type MissingNodeType = string | {
        type: string;
        hint?: string;
        action?: {
            text: string;
            callback: () => void;
        };
    };

    /** {@link Omit} all properties that evaluate to `never`. */
    declare type NeverNever<T> = {
        [K in keyof T as T[K] extends never ? never : K]: T[K];
    };

    declare type NodeId = z.infer<typeof zNodeId>;

    /** {@link Pick} only properties that evaluate to `never`. */
    declare type PickNevers<T> = {
        [K in keyof T as T[K] extends never ? K : never]: T[K];
    };

    declare type SettingCustomRenderer = (name: string, setter: (v: any) => void, value: any, attrs: any) => HTMLElement;

    declare type SettingInputType = 'boolean' | 'number' | 'slider' | 'knob' | 'combo' | 'text' | 'image' | 'color' | 'url' | 'hidden';

    declare interface SettingOption {
        text: string;
        value?: any;
    }

    declare interface SettingParams extends FormItem {
        id: keyof Settings;
        defaultValue: any | (() => any);
        onChange?: (newValue: any, oldValue?: any) => void;
        category?: string[];
        experimental?: boolean;
        deprecated?: boolean;
        migrateDeprecatedValue?: (value: any) => any;
        versionAdded?: string;
        versionModified?: string;
    }

    declare type SidebarTabExtension = VueSidebarTabExtension | CustomSidebarTabExtension;

    /** Keys (names) of API events that _do not_ pass a {@link CustomEvent} `detail` object. */
    declare type SimpleApiEvents = keyof PickNevers<ApiEventTypes>;

    declare interface TemplateInfo {
        name: string;
        tutorialUrl?: string;
        mediaType: string;
        mediaSubtype: string;
        thumbnailVariant?: string;
        description: string;
    }

    declare type ToastManager = {
        add(message: ToastMessageOptions): void;
        remove(message: ToastMessageOptions): void;
        removeAll(): void;
    };

    /**
     * Defines message options in Toast component.
     */
    declare interface ToastMessageOptions {
        /**
         * Severity level of the message.
         * @defaultValue info
         */
        severity?: 'success' | 'info' | 'warn' | 'error' | 'secondary' | 'contrast' | undefined;
        /**
         * Summary content of the message.
         */
        summary?: string | undefined;
        /**
         * Detail content of the message.
         */
        detail?: any | undefined;
        /**
         * Whether the message can be closed manually using the close icon.
         * @defaultValue true
         */
        closable?: boolean | undefined;
        /**
         * Delay in milliseconds to close the message automatically.
         */
        life?: number | undefined;
        /**
         * Key of the Toast to display the message.
         */
        group?: string | undefined;
        /**
         * Style class of the message.
         */
        styleClass?: any;
        /**
         * Style class of the content.
         */
        contentStyleClass?: any;
    }

    declare const useDialogService: () => {
        showLoadWorkflowWarning: (props: InstanceType<typeof default_2>["$props"]) => void;
        showMissingModelsWarning: (props: InstanceType<typeof default_3>["$props"]) => void;
        showSettingsDialog: (panel?: "about" | "keybinding" | "extension" | "server-config") => void;
        showAboutDialog: () => void;
        showExecutionErrorDialog: (props: InstanceType<typeof default_4>["$props"]) => void;
        showTemplateWorkflowsDialog: (props?: InstanceType<typeof default_5>["$props"]) => void;
        showIssueReportDialog: (props: InstanceType<typeof default_6>["$props"]) => void;
        showManagerDialog: (props?: InstanceType<typeof default_7>["$props"]) => void;
        showManagerProgressDialog: (options?: {
            props?: InstanceType<typeof default_8>["$props"];
        }) => {
            key: string;
            visible: boolean;
            title?: string;
            headerComponent?: FunctionalComponent<any, {}, any, {}> | {
                new (...args: any[]): any;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } | {
                [x: string]: any;
                setup?: ((this: void, props: LooseRequired<any>, ctx: {
                    attrs: {
                        [x: string]: unknown;
                    };
                    slots: Readonly<{
                        [name: string]: Slot<any> | undefined;
                    }>;
                    emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
                    expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
                }) => Promise<any> | any | RenderFunction | void) | undefined;
                name?: string;
                template?: string | object;
                render?: Function;
                components?: Record<string, Component<any, any, any, ComputedOptions, MethodOptions, {}, any>> | undefined;
                directives?: Record<string, Directive<any, any, string, string>> | undefined;
                inheritAttrs?: boolean;
                emits?: any;
                slots?: {} | undefined;
                expose?: string[] | undefined;
                serverPrefetch?: (() => void | Promise<any>) | undefined;
                compilerOptions?: {
                    isCustomElement?: (tag: string) => boolean;
                    whitespace?: "preserve" | "condense";
                    comments?: boolean;
                    delimiters?: [string, string];
                } | undefined;
                call?: (this: unknown, ...args: unknown[]) => never;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
                __defaults?: {} | undefined;
                compatConfig?: {
                    GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
                    GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
                    GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
                    GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
                    GLOBAL_SET?: boolean | "suppress-warning" | undefined;
                    GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
                    GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
                    GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
                    CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
                    CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
                    CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
                    CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
                    CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
                    CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
                    CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_SET?: boolean | "suppress-warning" | undefined;
                    INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
                    INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
                    INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
                    INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
                    INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
                    OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
                    OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
                    OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
                    OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
                    WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
                    PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
                    V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
                    CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
                    ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
                    ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
                    TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
                    TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
                    COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
                    COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
                    COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
                    RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
                    FILTERS?: boolean | "suppress-warning" | undefined;
                    PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
                    MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
                } | undefined;
                data?: ((this: any, vm: any) => any) | undefined;
                computed?: ComputedOptions | undefined;
                methods?: MethodOptions | undefined;
                watch?: {
                    [x: string]: (string | WatchCallback | ({
                        handler: WatchCallback | string;
                    } & WatchOptions<boolean>)) | (string | WatchCallback | ({
                        handler: WatchCallback | string;
                    } & WatchOptions<boolean>))[];
                };
                provide?: ComponentProvideOptions | undefined;
                inject?: {} | string[] | undefined;
                filters?: Record<string, Function>;
                mixins?: any[] | undefined;
                extends?: any;
                beforeCreate?: (() => void) | undefined;
                created?: (() => void) | undefined;
                beforeMount?: (() => void) | undefined;
                mounted?: (() => void) | undefined;
                beforeUpdate?: (() => void) | undefined;
                updated?: (() => void) | undefined;
                activated?: (() => void) | undefined;
                deactivated?: (() => void) | undefined;
                beforeDestroy?: (() => void) | undefined;
                beforeUnmount?: (() => void) | undefined;
                destroyed?: (() => void) | undefined;
                unmounted?: (() => void) | undefined;
                renderTracked?: (e: DebuggerEvent) => void;
                renderTriggered?: (e: DebuggerEvent) => void;
                errorCaptured?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void;
                delimiters?: [string, string];
                __differentiator?: string | number | symbol | undefined;
                __isBuiltIn?: boolean;
                __file?: string;
                __name?: string;
                i18n?: {
                    locale?: string | undefined;
                    fallbackLocale?: string | false | string[] | {
                        [x: string]: string[];
                    } | undefined;
                    messages?: {
                        [x: string]: LocaleMessage<VueMessageType>;
                    } | undefined;
                    flatJson?: boolean | undefined;
                    datetimeFormats?: {
                        [x: string]: IntlDateTimeFormat;
                    } | undefined;
                    numberFormats?: {
                        [x: string]: IntlNumberFormat;
                    } | undefined;
                    availableLocales?: Locale[];
                    modifiers?: LinkedModifiers<VueMessageType> | undefined;
                    formatter?: {
                        interpolate: (message: string, values: any, path: string) => Array<any> | null;
                    } | undefined;
                    missing?: MissingHandler | undefined;
                    fallbackRoot?: boolean | undefined;
                    silentTranslationWarn?: boolean | RegExp | undefined;
                    silentFallbackWarn?: boolean | RegExp | undefined;
                    formatFallbackMessages?: boolean | undefined;
                    preserveDirectiveContent?: boolean;
                    warnHtmlInMessage?: WarnHtmlInMessageLevel;
                    escapeParameterHtml?: boolean | undefined;
                    sharedMessages?: LocaleMessages<VueMessageType>;
                    pluralizationRules?: PluralizationRules | undefined;
                    postTranslation?: PostTranslationHandler<VueMessageType> | undefined;
                    sync?: boolean;
                    messageResolver?: MessageResolver;
                } | undefined;
                __i18n?: {
                    locale: Locale;
                    resource: LocaleMessages<VueMessageType>;
                }[] | undefined;
                __INTLIFY_META__?: string;
                beforeRouteEnter?: TypesConfig extends Record<"beforeRouteEnter", infer T> ? T : NavigationGuardWithThis<undefined>;
                beforeRouteUpdate?: TypesConfig extends Record<"beforeRouteUpdate", infer T> ? T : NavigationGuard;
                beforeRouteLeave?: TypesConfig extends Record<"beforeRouteLeave", infer T> ? T : NavigationGuard;
            } | undefined;
            component: FunctionalComponent<any, {}, any, {}> | {
                new (...args: any[]): any;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } | {
                [x: string]: any;
                setup?: ((this: void, props: LooseRequired<any>, ctx: {
                    attrs: {
                        [x: string]: unknown;
                    };
                    slots: Readonly<{
                        [name: string]: Slot<any> | undefined;
                    }>;
                    emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
                    expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
                }) => Promise<any> | any | RenderFunction | void) | undefined;
                name?: string;
                template?: string | object;
                render?: Function;
                components?: Record<string, Component<any, any, any, ComputedOptions, MethodOptions, {}, any>> | undefined;
                directives?: Record<string, Directive<any, any, string, string>> | undefined;
                inheritAttrs?: boolean;
                emits?: any;
                slots?: {} | undefined;
                expose?: string[] | undefined;
                serverPrefetch?: (() => void | Promise<any>) | undefined;
                compilerOptions?: {
                    isCustomElement?: (tag: string) => boolean;
                    whitespace?: "preserve" | "condense";
                    comments?: boolean;
                    delimiters?: [string, string];
                } | undefined;
                call?: (this: unknown, ...args: unknown[]) => never;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
                __defaults?: {} | undefined;
                compatConfig?: {
                    GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
                    GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
                    GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
                    GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
                    GLOBAL_SET?: boolean | "suppress-warning" | undefined;
                    GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
                    GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
                    GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
                    CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
                    CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
                    CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
                    CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
                    CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
                    CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
                    CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_SET?: boolean | "suppress-warning" | undefined;
                    INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
                    INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
                    INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
                    INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
                    INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
                    OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
                    OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
                    OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
                    OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
                    WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
                    PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
                    V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
                    CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
                    ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
                    ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
                    TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
                    TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
                    COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
                    COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
                    COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
                    RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
                    FILTERS?: boolean | "suppress-warning" | undefined;
                    PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
                    MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
                } | undefined;
                data?: ((this: any, vm: any) => any) | undefined;
                computed?: ComputedOptions | undefined;
                methods?: MethodOptions | undefined;
                watch?: {
                    [x: string]: (string | WatchCallback | ({
                        handler: WatchCallback | string;
                    } & WatchOptions<boolean>)) | (string | WatchCallback | ({
                        handler: WatchCallback | string;
                    } & WatchOptions<boolean>))[];
                };
                provide?: ComponentProvideOptions | undefined;
                inject?: {} | string[] | undefined;
                filters?: Record<string, Function>;
                mixins?: any[] | undefined;
                extends?: any;
                beforeCreate?: (() => void) | undefined;
                created?: (() => void) | undefined;
                beforeMount?: (() => void) | undefined;
                mounted?: (() => void) | undefined;
                beforeUpdate?: (() => void) | undefined;
                updated?: (() => void) | undefined;
                activated?: (() => void) | undefined;
                deactivated?: (() => void) | undefined;
                beforeDestroy?: (() => void) | undefined;
                beforeUnmount?: (() => void) | undefined;
                destroyed?: (() => void) | undefined;
                unmounted?: (() => void) | undefined;
                renderTracked?: (e: DebuggerEvent) => void;
                renderTriggered?: (e: DebuggerEvent) => void;
                errorCaptured?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void;
                delimiters?: [string, string];
                __differentiator?: string | number | symbol | undefined;
                __isBuiltIn?: boolean;
                __file?: string;
                __name?: string;
                i18n?: {
                    locale?: string | undefined;
                    fallbackLocale?: string | false | string[] | {
                        [x: string]: string[];
                    } | undefined;
                    messages?: {
                        [x: string]: LocaleMessage<VueMessageType>;
                    } | undefined;
                    flatJson?: boolean | undefined;
                    datetimeFormats?: {
                        [x: string]: IntlDateTimeFormat;
                    } | undefined;
                    numberFormats?: {
                        [x: string]: IntlNumberFormat;
                    } | undefined;
                    availableLocales?: Locale[];
                    modifiers?: LinkedModifiers<VueMessageType> | undefined;
                    formatter?: {
                        interpolate: (message: string, values: any, path: string) => Array<any> | null;
                    } | undefined;
                    missing?: MissingHandler | undefined;
                    fallbackRoot?: boolean | undefined;
                    silentTranslationWarn?: boolean | RegExp | undefined;
                    silentFallbackWarn?: boolean | RegExp | undefined;
                    formatFallbackMessages?: boolean | undefined;
                    preserveDirectiveContent?: boolean;
                    warnHtmlInMessage?: WarnHtmlInMessageLevel;
                    escapeParameterHtml?: boolean | undefined;
                    sharedMessages?: LocaleMessages<VueMessageType>;
                    pluralizationRules?: PluralizationRules | undefined;
                    postTranslation?: PostTranslationHandler<VueMessageType> | undefined;
                    sync?: boolean;
                    messageResolver?: MessageResolver;
                } | undefined;
                __i18n?: {
                    locale: Locale;
                    resource: LocaleMessages<VueMessageType>;
                }[] | undefined;
                __INTLIFY_META__?: string;
                beforeRouteEnter?: TypesConfig extends Record<"beforeRouteEnter", infer T> ? T : NavigationGuardWithThis<undefined>;
                beforeRouteUpdate?: TypesConfig extends Record<"beforeRouteUpdate", infer T> ? T : NavigationGuard;
                beforeRouteLeave?: TypesConfig extends Record<"beforeRouteLeave", infer T> ? T : NavigationGuard;
            };
            contentProps: Record<string, any>;
            footerComponent?: FunctionalComponent<any, {}, any, {}> | {
                new (...args: any[]): any;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } | {
                [x: string]: any;
                setup?: ((this: void, props: LooseRequired<any>, ctx: {
                    attrs: {
                        [x: string]: unknown;
                    };
                    slots: Readonly<{
                        [name: string]: Slot<any> | undefined;
                    }>;
                    emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
                    expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
                }) => Promise<any> | any | RenderFunction | void) | undefined;
                name?: string;
                template?: string | object;
                render?: Function;
                components?: Record<string, Component<any, any, any, ComputedOptions, MethodOptions, {}, any>> | undefined;
                directives?: Record<string, Directive<any, any, string, string>> | undefined;
                inheritAttrs?: boolean;
                emits?: any;
                slots?: {} | undefined;
                expose?: string[] | undefined;
                serverPrefetch?: (() => void | Promise<any>) | undefined;
                compilerOptions?: {
                    isCustomElement?: (tag: string) => boolean;
                    whitespace?: "preserve" | "condense";
                    comments?: boolean;
                    delimiters?: [string, string];
                } | undefined;
                call?: (this: unknown, ...args: unknown[]) => never;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
                __defaults?: {} | undefined;
                compatConfig?: {
                    GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
                    GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
                    GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
                    GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
                    GLOBAL_SET?: boolean | "suppress-warning" | undefined;
                    GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
                    GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
                    GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
                    CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
                    CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
                    CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
                    CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
                    CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
                    CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
                    CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_SET?: boolean | "suppress-warning" | undefined;
                    INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
                    INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
                    INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
                    INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
                    INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
                    INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
                    OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
                    OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
                    OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
                    OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
                    WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
                    PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
                    V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
                    CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
                    ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
                    ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
                    TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
                    TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
                    COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
                    COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
                    COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
                    RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
                    FILTERS?: boolean | "suppress-warning" | undefined;
                    PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
                    MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
                } | undefined;
                data?: ((this: any, vm: any) => any) | undefined;
                computed?: ComputedOptions | undefined;
                methods?: MethodOptions | undefined;
                watch?: {
                    [x: string]: (string | WatchCallback | ({
                        handler: WatchCallback | string;
                    } & WatchOptions<boolean>)) | (string | WatchCallback | ({
                        handler: WatchCallback | string;
                    } & WatchOptions<boolean>))[];
                };
                provide?: ComponentProvideOptions | undefined;
                inject?: {} | string[] | undefined;
                filters?: Record<string, Function>;
                mixins?: any[] | undefined;
                extends?: any;
                beforeCreate?: (() => void) | undefined;
                created?: (() => void) | undefined;
                beforeMount?: (() => void) | undefined;
                mounted?: (() => void) | undefined;
                beforeUpdate?: (() => void) | undefined;
                updated?: (() => void) | undefined;
                activated?: (() => void) | undefined;
                deactivated?: (() => void) | undefined;
                beforeDestroy?: (() => void) | undefined;
                beforeUnmount?: (() => void) | undefined;
                destroyed?: (() => void) | undefined;
                unmounted?: (() => void) | undefined;
                renderTracked?: (e: DebuggerEvent) => void;
                renderTriggered?: (e: DebuggerEvent) => void;
                errorCaptured?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void;
                delimiters?: [string, string];
                __differentiator?: string | number | symbol | undefined;
                __isBuiltIn?: boolean;
                __file?: string;
                __name?: string;
                i18n?: {
                    locale?: string | undefined;
                    fallbackLocale?: string | false | string[] | {
                        [x: string]: string[];
                    } | undefined;
                    messages?: {
                        [x: string]: LocaleMessage<VueMessageType>;
                    } | undefined;
                    flatJson?: boolean | undefined;
                    datetimeFormats?: {
                        [x: string]: IntlDateTimeFormat;
                    } | undefined;
                    numberFormats?: {
                        [x: string]: IntlNumberFormat;
                    } | undefined;
                    availableLocales?: Locale[];
                    modifiers?: LinkedModifiers<VueMessageType> | undefined;
                    formatter?: {
                        interpolate: (message: string, values: any, path: string) => Array<any> | null;
                    } | undefined;
                    missing?: MissingHandler | undefined;
                    fallbackRoot?: boolean | undefined;
                    silentTranslationWarn?: boolean | RegExp | undefined;
                    silentFallbackWarn?: boolean | RegExp | undefined;
                    formatFallbackMessages?: boolean | undefined;
                    preserveDirectiveContent?: boolean;
                    warnHtmlInMessage?: WarnHtmlInMessageLevel;
                    escapeParameterHtml?: boolean | undefined;
                    sharedMessages?: LocaleMessages<VueMessageType>;
                    pluralizationRules?: PluralizationRules | undefined;
                    postTranslation?: PostTranslationHandler<VueMessageType> | undefined;
                    sync?: boolean;
                    messageResolver?: MessageResolver;
                } | undefined;
                __i18n?: {
                    locale: Locale;
                    resource: LocaleMessages<VueMessageType>;
                }[] | undefined;
                __INTLIFY_META__?: string;
                beforeRouteEnter?: TypesConfig extends Record<"beforeRouteEnter", infer T> ? T : NavigationGuardWithThis<undefined>;
                beforeRouteUpdate?: TypesConfig extends Record<"beforeRouteUpdate", infer T> ? T : NavigationGuard;
                beforeRouteLeave?: TypesConfig extends Record<"beforeRouteLeave", infer T> ? T : NavigationGuard;
            } | undefined;
            dialogComponentProps: {
                key?: PropertyKey;
                ref?: any;
                ref_for?: boolean;
                ref_key?: string;
                onVnodeBeforeMount?: ((vnode: VNode) => void) | ((vnode: VNode) => void)[];
                onVnodeMounted?: ((vnode: VNode) => void) | ((vnode: VNode) => void)[];
                onVnodeBeforeUpdate?: ((vnode: VNode, oldVNode: VNode) => void) | ((vnode: VNode, oldVNode: VNode) => void)[];
                onVnodeUpdated?: ((vnode: VNode, oldVNode: VNode) => void) | ((vnode: VNode, oldVNode: VNode) => void)[];
                onVnodeBeforeUnmount?: ((vnode: VNode) => void) | ((vnode: VNode) => void)[];
                onVnodeUnmounted?: ((vnode: VNode) => void) | ((vnode: VNode) => void)[];
                class?: unknown;
                style?: unknown;
                maximizable?: boolean;
                maximized?: boolean;
                onClose?: () => void;
                closable?: boolean;
                modal?: boolean;
                position?: "left" | "top" | "right" | "bottom" | "center" | "topleft" | "topright" | "bottomleft" | "bottomright";
                pt?: {
                    root?: DialogPassThroughOptionType<any>;
                    header?: DialogPassThroughOptionType<any>;
                    title?: DialogPassThroughOptionType<any>;
                    headerActions?: DialogPassThroughOptionType<any>;
                    pcMaximizeButton?: {
                        root?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        loadingIcon?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        icon?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        label?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        pcBadge?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        hooks?: {
                            onBeforeCreate?: (() => void) | undefined;
                            onCreated?: (() => void) | undefined;
                            onBeforeMount?: (() => void) | undefined;
                            onMounted?: (() => void) | undefined;
                            onBeforeUpdate?: (() => void) | undefined;
                            onUpdated?: (() => void) | undefined;
                            onBeforeUnmount?: (() => void) | undefined;
                            onUnmounted?: (() => void) | undefined;
                        } | undefined;
                    } | undefined;
                    pcCloseButton?: {
                        root?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        loadingIcon?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        icon?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        label?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        pcBadge?: ButtonPassThroughOptionType<DialogSharedPassThroughMethodOptions>;
                        hooks?: {
                            onBeforeCreate?: (() => void) | undefined;
                            onCreated?: (() => void) | undefined;
                            onBeforeMount?: (() => void) | undefined;
                            onMounted?: (() => void) | undefined;
                            onBeforeUpdate?: (() => void) | undefined;
                            onUpdated?: (() => void) | undefined;
                            onBeforeUnmount?: (() => void) | undefined;
                            onUnmounted?: (() => void) | undefined;
                        } | undefined;
                    } | undefined;
                    content?: DialogPassThroughOptionType<any>;
                    footer?: DialogPassThroughOptionType<any>;
                    mask?: DialogPassThroughOptionType<any>;
                    hooks?: {
                        onBeforeCreate?: (() => void) | undefined;
                        onCreated?: (() => void) | undefined;
                        onBeforeMount?: (() => void) | undefined;
                        onMounted?: (() => void) | undefined;
                        onBeforeUpdate?: (() => void) | undefined;
                        onUpdated?: (() => void) | undefined;
                        onBeforeUnmount?: (() => void) | undefined;
                        onUnmounted?: (() => void) | undefined;
                    } | undefined;
                    transition?: ((options: DialogPassThroughMethodOptions<any>) => TransitionProps) | {
                        name?: string;
                        type?: "animation" | "transition";
                        css?: boolean;
                        duration?: number | {
                            enter: number;
                            leave: number;
                        } | undefined;
                        enterFromClass?: string;
                        enterActiveClass?: string;
                        enterToClass?: string;
                        appearFromClass?: string;
                        appearActiveClass?: string;
                        appearToClass?: string;
                        leaveFromClass?: string;
                        leaveActiveClass?: string;
                        leaveToClass?: string;
                        mode?: "in-out" | "out-in" | "default";
                        appear?: boolean;
                        persisted?: boolean;
                        onBeforeEnter?: (((el: Element) => void) | ((el: Element) => void)[]) | undefined;
                        onEnter?: (((el: Element, done: () => void) => void) | ((el: Element, done: () => void) => void)[]) | undefined;
                        onAfterEnter?: (((el: Element) => void) | ((el: Element) => void)[]) | undefined;
                        onEnterCancelled?: (((el: Element) => void) | ((el: Element) => void)[]) | undefined;
                        onBeforeLeave?: (((el: Element) => void) | ((el: Element) => void)[]) | undefined;
                        onLeave?: (((el: Element, done: () => void) => void) | ((el: Element, done: () => void) => void)[]) | undefined;
                        onAfterLeave?: (((el: Element) => void) | ((el: Element) => void)[]) | undefined;
                        onLeaveCancelled?: (((el: Element) => void) | ((el: Element) => void)[]) | undefined;
                        onBeforeAppear?: (((el: Element) => void) | ((el: Element) => void)[]) | undefined;
                        onAppear?: (((el: Element, done: () => void) => void) | ((el: Element, done: () => void) => void)[]) | undefined;
                        onAfterAppear?: (((el: Element) => void) | ((el: Element) => void)[]) | undefined;
                        onAppearCancelled?: (((el: Element) => void) | ((el: Element) => void)[]) | undefined;
                    } | undefined;
                } | undefined;
            };
        };
        prompt: ({ title, message, defaultValue }: {
            title: string;
            message: string;
            defaultValue?: string;
        }) => Promise<string | null>;
        confirm: ({ title, message, type, itemList, hint }: {
            /** Dialog heading */
            title: string;
            /** The main message body */
            message: string;
            /** Pre-configured dialog type */
            type?: ConfirmationDialogType;
            /** Displayed as an unordered list immediately below the message body */
            itemList?: string[];
            hint?: string;
        }) => Promise<boolean | null>;
    };

    /**
     * Represents a file in the user's data directory.
     */
    declare class UserFile {
        /**
         * Path relative to ComfyUI/user/ directory.
         */
        path: string;
        /**
         * Last modified timestamp.
         */
        lastModified: number;
        /**
         * File size in bytes. -1 for temporary files.
         */
        size: number;
        /**
         * Various path components.
         * Example:
         * - path: 'dir/file.txt'
         * - directory: 'dir'
         * - fullFilename: 'file.txt'
         * - filename: 'file'
         * - suffix: 'txt'
         */
        directory: string;
        fullFilename: string;
        filename: string;
        suffix: string | null;
        isLoading: boolean;
        content: string | null;
        originalContent: string | null;
        constructor(
        /**
         * Path relative to ComfyUI/user/ directory.
         */
        path: string, 
        /**
         * Last modified timestamp.
         */
        lastModified: number, 
        /**
         * File size in bytes. -1 for temporary files.
         */
        size: number);
        updatePath(newPath: string): void;
        static createTemporary(path: string): UserFile;
        get isTemporary(): boolean;
        get isPersisted(): boolean;
        get key(): string;
        get isLoaded(): boolean;
        get isModified(): boolean;
        /**
         * Loads the file content from the remote storage.
         */
        load({ force }?: {
            force?: boolean;
        }): Promise<LoadedUserFile>;
        /**
         * Unloads the file content from memory
         */
        unload(): void;
        saveAs(newPath: string): Promise<UserFile>;
        /**
         * Saves the file to the remote storage.
         * @param force Whether to force the save even if the file is not modified.
         */
        save({ force }?: {
            force?: boolean;
        }): Promise<UserFile>;
        delete(): Promise<void>;
        rename(newPath: string): Promise<UserFile>;
    }

    declare type VueBottomPanelExtension = BaseBottomPanelExtension & VueExtension;

    declare interface VueExtension {
        id: string;
        type: 'vue';
        component: Component;
    }

    declare type VueSidebarTabExtension = BaseSidebarTabExtension & VueExtension;

    declare type Widgets = Record<string, ComfyWidgetConstructor>;

    declare interface WorkflowTemplates {
        moduleName: string;
        templates: TemplateInfo[];
        title: string;
    }

    declare const zComfyApiWorkflow: z.ZodRecord<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodObject<{
        inputs: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodAny, z.ZodTuple<[z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>], null>]>>;
        class_type: z.ZodString;
        _meta: z.ZodObject<{
            title: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            title: string;
        }, {
            title: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        inputs: Record<string, any>;
        class_type: string;
        _meta: {
            title: string;
        };
    }, {
        inputs: Record<string, any>;
        class_type: string;
        _meta: {
            title: string;
        };
    }>>;

    declare const zComfyNodeDef: z.ZodObject<{
        input: z.ZodOptional<z.ZodObject<{
            required: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodTuple<[z.ZodLiteral<"INT">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"FLOAT">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"BOOLEAN">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"STRING">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"COMBO">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodEffects<z.ZodString, string, string>, z.ZodOptional<z.ZodObject<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>>], null>]>>>;
            optional: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodTuple<[z.ZodLiteral<"INT">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"FLOAT">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"BOOLEAN">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"STRING">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"COMBO">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodEffects<z.ZodString, string, string>, z.ZodOptional<z.ZodObject<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>>], null>]>>>;
            hidden: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        }, "strip", z.ZodTypeAny, {
            required?: Record<string, ["INT", z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["FLOAT", z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["BOOLEAN", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["STRING", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [(string | number)[], z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["COMBO", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [string, z.objectOutputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough"> | undefined]> | undefined;
            hidden?: Record<string, any> | undefined;
            optional?: Record<string, ["INT", z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["FLOAT", z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["BOOLEAN", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["STRING", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [(string | number)[], z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["COMBO", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [string, z.objectOutputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough"> | undefined]> | undefined;
        }, {
            required?: Record<string, ["INT", z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["FLOAT", z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["BOOLEAN", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["STRING", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [(string | number)[], z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["COMBO", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [string, z.objectInputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough"> | undefined]> | undefined;
            hidden?: Record<string, any> | undefined;
            optional?: Record<string, ["INT", z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["FLOAT", z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["BOOLEAN", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["STRING", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [(string | number)[], z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["COMBO", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [string, z.objectInputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough"> | undefined]> | undefined;
        }>>;
        output: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">]>, "many">>;
        output_is_list: z.ZodOptional<z.ZodArray<z.ZodBoolean, "many">>;
        output_name: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        output_tooltips: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        name: z.ZodString;
        display_name: z.ZodString;
        description: z.ZodString;
        category: z.ZodString;
        output_node: z.ZodBoolean;
        python_module: z.ZodString;
        deprecated: z.ZodOptional<z.ZodBoolean>;
        experimental: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        description: string;
        name: string;
        category: string;
        display_name: string;
        output_node: boolean;
        python_module: string;
        deprecated?: boolean | undefined;
        input?: {
            required?: Record<string, ["INT", z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["FLOAT", z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["BOOLEAN", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["STRING", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [(string | number)[], z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["COMBO", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [string, z.objectOutputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough"> | undefined]> | undefined;
            hidden?: Record<string, any> | undefined;
            optional?: Record<string, ["INT", z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["FLOAT", z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["BOOLEAN", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["STRING", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [(string | number)[], z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["COMBO", z.objectOutputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [string, z.objectOutputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough"> | undefined]> | undefined;
        } | undefined;
        output?: (string | (string | number)[])[] | undefined;
        experimental?: boolean | undefined;
        output_is_list?: boolean[] | undefined;
        output_name?: string[] | undefined;
        output_tooltips?: string[] | undefined;
    }, {
        description: string;
        name: string;
        category: string;
        display_name: string;
        output_node: boolean;
        python_module: string;
        deprecated?: boolean | undefined;
        input?: {
            required?: Record<string, ["INT", z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["FLOAT", z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["BOOLEAN", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["STRING", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [(string | number)[], z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["COMBO", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [string, z.objectInputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough"> | undefined]> | undefined;
            hidden?: Record<string, any> | undefined;
            optional?: Record<string, ["INT", z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                /**
                 * If true, a linked widget will be added to the node to select the mode
                 * of `control_after_generate`.
                 */
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["FLOAT", z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                min: z.ZodOptional<z.ZodNumber>;
                max: z.ZodOptional<z.ZodNumber>;
                step: z.ZodOptional<z.ZodNumber>;
                default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
                display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
            }>, {
                round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["BOOLEAN", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                label_on: z.ZodOptional<z.ZodString>;
                label_off: z.ZodOptional<z.ZodString>;
                default: z.ZodOptional<z.ZodBoolean>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["STRING", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                default: z.ZodOptional<z.ZodString>;
                multiline: z.ZodOptional<z.ZodBoolean>;
                dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
                defaultVal: z.ZodOptional<z.ZodString>;
                placeholder: z.ZodOptional<z.ZodString>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [(string | number)[], z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | ["COMBO", z.objectInputType<z.objectUtil.extendShape<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, {
                control_after_generate: z.ZodOptional<z.ZodBoolean>;
                image_upload: z.ZodOptional<z.ZodBoolean>;
                image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
                allow_batch: z.ZodOptional<z.ZodBoolean>;
                video_upload: z.ZodOptional<z.ZodBoolean>;
                options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
                remote: z.ZodOptional<z.ZodObject<{
                    route: z.ZodUnion<[z.ZodString, z.ZodString]>;
                    refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
                    response_key: z.ZodOptional<z.ZodString>;
                    query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    refresh_button: z.ZodOptional<z.ZodBoolean>;
                    control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
                    timeout: z.ZodOptional<z.ZodNumber>;
                    max_retries: z.ZodOptional<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }, {
                    route: string;
                    refresh?: number | undefined;
                    response_key?: string | undefined;
                    query_params?: Record<string, string> | undefined;
                    refresh_button?: boolean | undefined;
                    control_after_refresh?: "first" | "last" | undefined;
                    timeout?: number | undefined;
                    max_retries?: number | undefined;
                }>>;
                /** Whether the widget is a multi-select widget. */
                multi_select: z.ZodOptional<z.ZodObject<{
                    placeholder: z.ZodOptional<z.ZodString>;
                    chip: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }, {
                    placeholder?: string | undefined;
                    chip?: boolean | undefined;
                }>>;
            }>, z.ZodTypeAny, "passthrough"> | undefined] | [string, z.objectInputType<{
                default: z.ZodOptional<z.ZodAny>;
                defaultInput: z.ZodOptional<z.ZodBoolean>;
                forceInput: z.ZodOptional<z.ZodBoolean>;
                tooltip: z.ZodOptional<z.ZodString>;
                hidden: z.ZodOptional<z.ZodBoolean>;
                advanced: z.ZodOptional<z.ZodBoolean>;
                /** Backend-only properties. */
                rawLink: z.ZodOptional<z.ZodBoolean>;
                lazy: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough"> | undefined]> | undefined;
        } | undefined;
        output?: (string | (string | number)[])[] | undefined;
        experimental?: boolean | undefined;
        output_is_list?: boolean[] | undefined;
        output_name?: string[] | undefined;
        output_tooltips?: string[] | undefined;
    }>;

    /** Schema version 0.4 */
    declare const zComfyWorkflow: z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        revision: z.ZodOptional<z.ZodNumber>;
        last_node_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
        last_link_id: z.ZodNumber;
        nodes: z.ZodArray<z.ZodObject<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        links: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>, z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>], null>, "many">;
        floatingLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        config: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>>>;
        extra: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">>>>;
        version: z.ZodNumber;
        models: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            url: z.ZodString;
            hash: z.ZodOptional<z.ZodString>;
            hash_type: z.ZodOptional<z.ZodString>;
            directory: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodOptional<z.ZodString>;
        revision: z.ZodOptional<z.ZodNumber>;
        last_node_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
        last_link_id: z.ZodNumber;
        nodes: z.ZodArray<z.ZodObject<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        links: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>, z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>], null>, "many">;
        floatingLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        config: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>>>;
        extra: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">>>>;
        version: z.ZodNumber;
        models: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            url: z.ZodString;
            hash: z.ZodOptional<z.ZodString>;
            hash_type: z.ZodOptional<z.ZodString>;
            directory: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodOptional<z.ZodString>;
        revision: z.ZodOptional<z.ZodNumber>;
        last_node_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
        last_link_id: z.ZodNumber;
        nodes: z.ZodArray<z.ZodObject<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        links: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>, z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>], null>, "many">;
        floatingLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        config: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>>>;
        extra: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">>>>;
        version: z.ZodNumber;
        models: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            url: z.ZodString;
            hash: z.ZodOptional<z.ZodString>;
            hash_type: z.ZodOptional<z.ZodString>;
            directory: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }>, "many">>;
    }, z.ZodTypeAny, "passthrough">>;

    /** Schema version 1 */
    declare const zComfyWorkflow1: z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        revision: z.ZodOptional<z.ZodNumber>;
        version: z.ZodLiteral<1>;
        config: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>>>;
        state: z.ZodObject<{
            lastGroupid: z.ZodOptional<z.ZodNumber>;
            lastNodeId: z.ZodOptional<z.ZodNumber>;
            lastLinkId: z.ZodOptional<z.ZodNumber>;
            lastRerouteId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            lastGroupid: z.ZodOptional<z.ZodNumber>;
            lastNodeId: z.ZodOptional<z.ZodNumber>;
            lastLinkId: z.ZodOptional<z.ZodNumber>;
            lastRerouteId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            lastGroupid: z.ZodOptional<z.ZodNumber>;
            lastNodeId: z.ZodOptional<z.ZodNumber>;
            lastLinkId: z.ZodOptional<z.ZodNumber>;
            lastRerouteId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>;
        groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        nodes: z.ZodArray<z.ZodObject<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        floatingLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodNumber>;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodNumber>;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodNumber>;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        extra: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">>>>;
        models: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            url: z.ZodString;
            hash: z.ZodOptional<z.ZodString>;
            hash_type: z.ZodOptional<z.ZodString>;
            directory: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }>, "many">>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        id: z.ZodOptional<z.ZodString>;
        revision: z.ZodOptional<z.ZodNumber>;
        version: z.ZodLiteral<1>;
        config: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>>>;
        state: z.ZodObject<{
            lastGroupid: z.ZodOptional<z.ZodNumber>;
            lastNodeId: z.ZodOptional<z.ZodNumber>;
            lastLinkId: z.ZodOptional<z.ZodNumber>;
            lastRerouteId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            lastGroupid: z.ZodOptional<z.ZodNumber>;
            lastNodeId: z.ZodOptional<z.ZodNumber>;
            lastLinkId: z.ZodOptional<z.ZodNumber>;
            lastRerouteId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            lastGroupid: z.ZodOptional<z.ZodNumber>;
            lastNodeId: z.ZodOptional<z.ZodNumber>;
            lastLinkId: z.ZodOptional<z.ZodNumber>;
            lastRerouteId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>;
        groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        nodes: z.ZodArray<z.ZodObject<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        floatingLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodNumber>;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodNumber>;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodNumber>;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        extra: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">>>>;
        models: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            url: z.ZodString;
            hash: z.ZodOptional<z.ZodString>;
            hash_type: z.ZodOptional<z.ZodString>;
            directory: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }>, "many">>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        id: z.ZodOptional<z.ZodString>;
        revision: z.ZodOptional<z.ZodNumber>;
        version: z.ZodLiteral<1>;
        config: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            links_ontop: z.ZodOptional<z.ZodBoolean>;
            align_to_grid: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>>>;
        state: z.ZodObject<{
            lastGroupid: z.ZodOptional<z.ZodNumber>;
            lastNodeId: z.ZodOptional<z.ZodNumber>;
            lastLinkId: z.ZodOptional<z.ZodNumber>;
            lastRerouteId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            lastGroupid: z.ZodOptional<z.ZodNumber>;
            lastNodeId: z.ZodOptional<z.ZodNumber>;
            lastLinkId: z.ZodOptional<z.ZodNumber>;
            lastRerouteId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            lastGroupid: z.ZodOptional<z.ZodNumber>;
            lastNodeId: z.ZodOptional<z.ZodNumber>;
            lastLinkId: z.ZodOptional<z.ZodNumber>;
            lastRerouteId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>;
        groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            title: z.ZodString;
            bounding: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
            color: z.ZodOptional<z.ZodString>;
            font_size: z.ZodOptional<z.ZodNumber>;
            locked: z.ZodOptional<z.ZodBoolean>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        nodes: z.ZodArray<z.ZodObject<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            type: z.ZodString;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            size: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            flags: z.ZodObject<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                collapsed: z.ZodOptional<z.ZodBoolean>;
                pinned: z.ZodOptional<z.ZodBoolean>;
                allow_interaction: z.ZodOptional<z.ZodBoolean>;
                horizontal: z.ZodOptional<z.ZodBoolean>;
                skip_repeated_outputs: z.ZodOptional<z.ZodBoolean>;
            }, z.ZodTypeAny, "passthrough">>;
            order: z.ZodNumber;
            mode: z.ZodNumber;
            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                link: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
                links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
                slot_index: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            properties: z.ZodObject<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                "Node name for S&R": z.ZodOptional<z.ZodString>;
                cnr_id: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                aux_id: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string[], string>, string[], string>, string, string>>;
                ver: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
                models: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    url: z.ZodString;
                    hash: z.ZodOptional<z.ZodString>;
                    hash_type: z.ZodOptional<z.ZodString>;
                    directory: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }, {
                    name: string;
                    url: string;
                    directory: string;
                    hash?: string | undefined;
                    hash_type?: string | undefined;
                }>, "many">>;
            }, z.ZodTypeAny, "passthrough">>;
            widgets_values: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodAny, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
            color: z.ZodOptional<z.ZodString>;
            bgcolor: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>, "many">;
        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        floatingLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            origin_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            origin_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
            target_slot: z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodEffects<z.ZodString, number, string>, number, string>]>;
            type: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber]>;
            parentId: z.ZodOptional<z.ZodNumber>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodNumber>;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            id: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodNumber>;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            id: z.ZodNumber;
            parentId: z.ZodOptional<z.ZodNumber>;
            pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                0: z.ZodNumber;
                1: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
        }, z.ZodTypeAny, "passthrough">>, "many">>;
        extra: z.ZodNullable<z.ZodOptional<z.ZodObject<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            ds: z.ZodOptional<z.ZodObject<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                scale: z.ZodNumber;
                offset: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
            }, z.ZodTypeAny, "passthrough">>>;
            info: z.ZodOptional<z.ZodObject<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                name: z.ZodString;
                author: z.ZodString;
                description: z.ZodString;
                version: z.ZodString;
                created: z.ZodString;
                modified: z.ZodString;
                software: z.ZodString;
            }, z.ZodTypeAny, "passthrough">>>;
            linkExtensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodNumber;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
            reroutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                id: z.ZodNumber;
                parentId: z.ZodOptional<z.ZodNumber>;
                pos: z.ZodUnion<[z.ZodEffects<z.ZodObject<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, [number, number], z.objectInputType<{
                    0: z.ZodNumber;
                    1: z.ZodNumber;
                }, z.ZodTypeAny, "passthrough">>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
                linkIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>>;
            }, z.ZodTypeAny, "passthrough">>, "many">>;
        }, z.ZodTypeAny, "passthrough">>>>;
        models: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            url: z.ZodString;
            hash: z.ZodOptional<z.ZodString>;
            hash_type: z.ZodOptional<z.ZodString>;
            directory: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }, {
            name: string;
            url: string;
            directory: string;
            hash?: string | undefined;
            hash_type?: string | undefined;
        }>, "many">>;
    }, z.ZodTypeAny, "passthrough">>;

    declare const zInputSpec: z.ZodUnion<[z.ZodTuple<[z.ZodLiteral<"INT">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        min: z.ZodOptional<z.ZodNumber>;
        max: z.ZodOptional<z.ZodNumber>;
        step: z.ZodOptional<z.ZodNumber>;
        default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
        display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
    }>, {
        /**
         * If true, a linked widget will be added to the node to select the mode
         * of `control_after_generate`.
         */
        control_after_generate: z.ZodOptional<z.ZodBoolean>;
    }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        min: z.ZodOptional<z.ZodNumber>;
        max: z.ZodOptional<z.ZodNumber>;
        step: z.ZodOptional<z.ZodNumber>;
        default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
        display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
    }>, {
        /**
         * If true, a linked widget will be added to the node to select the mode
         * of `control_after_generate`.
         */
        control_after_generate: z.ZodOptional<z.ZodBoolean>;
    }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        min: z.ZodOptional<z.ZodNumber>;
        max: z.ZodOptional<z.ZodNumber>;
        step: z.ZodOptional<z.ZodNumber>;
        default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
        display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
    }>, {
        /**
         * If true, a linked widget will be added to the node to select the mode
         * of `control_after_generate`.
         */
        control_after_generate: z.ZodOptional<z.ZodBoolean>;
    }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"FLOAT">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        min: z.ZodOptional<z.ZodNumber>;
        max: z.ZodOptional<z.ZodNumber>;
        step: z.ZodOptional<z.ZodNumber>;
        default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
        display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
    }>, {
        round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
    }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        min: z.ZodOptional<z.ZodNumber>;
        max: z.ZodOptional<z.ZodNumber>;
        step: z.ZodOptional<z.ZodNumber>;
        default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
        display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
    }>, {
        round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
    }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        min: z.ZodOptional<z.ZodNumber>;
        max: z.ZodOptional<z.ZodNumber>;
        step: z.ZodOptional<z.ZodNumber>;
        default: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
        display: z.ZodOptional<z.ZodEnum<["slider", "number", "knob"]>>;
    }>, {
        round: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<false>]>>;
    }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"BOOLEAN">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        label_on: z.ZodOptional<z.ZodString>;
        label_off: z.ZodOptional<z.ZodString>;
        default: z.ZodOptional<z.ZodBoolean>;
    }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        label_on: z.ZodOptional<z.ZodString>;
        label_off: z.ZodOptional<z.ZodString>;
        default: z.ZodOptional<z.ZodBoolean>;
    }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        label_on: z.ZodOptional<z.ZodString>;
        label_off: z.ZodOptional<z.ZodString>;
        default: z.ZodOptional<z.ZodBoolean>;
    }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"STRING">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        default: z.ZodOptional<z.ZodString>;
        multiline: z.ZodOptional<z.ZodBoolean>;
        dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
        defaultVal: z.ZodOptional<z.ZodString>;
        placeholder: z.ZodOptional<z.ZodString>;
    }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        default: z.ZodOptional<z.ZodString>;
        multiline: z.ZodOptional<z.ZodBoolean>;
        dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
        defaultVal: z.ZodOptional<z.ZodString>;
        placeholder: z.ZodOptional<z.ZodString>;
    }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        default: z.ZodOptional<z.ZodString>;
        multiline: z.ZodOptional<z.ZodBoolean>;
        dynamicPrompts: z.ZodOptional<z.ZodBoolean>;
        defaultVal: z.ZodOptional<z.ZodString>;
        placeholder: z.ZodOptional<z.ZodString>;
    }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        control_after_generate: z.ZodOptional<z.ZodBoolean>;
        image_upload: z.ZodOptional<z.ZodBoolean>;
        image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
        allow_batch: z.ZodOptional<z.ZodBoolean>;
        video_upload: z.ZodOptional<z.ZodBoolean>;
        options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
        remote: z.ZodOptional<z.ZodObject<{
            route: z.ZodUnion<[z.ZodString, z.ZodString]>;
            refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
            response_key: z.ZodOptional<z.ZodString>;
            query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            refresh_button: z.ZodOptional<z.ZodBoolean>;
            control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
            timeout: z.ZodOptional<z.ZodNumber>;
            max_retries: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }>>;
        /** Whether the widget is a multi-select widget. */
        multi_select: z.ZodOptional<z.ZodObject<{
            placeholder: z.ZodOptional<z.ZodString>;
            chip: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }>>;
    }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        control_after_generate: z.ZodOptional<z.ZodBoolean>;
        image_upload: z.ZodOptional<z.ZodBoolean>;
        image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
        allow_batch: z.ZodOptional<z.ZodBoolean>;
        video_upload: z.ZodOptional<z.ZodBoolean>;
        options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
        remote: z.ZodOptional<z.ZodObject<{
            route: z.ZodUnion<[z.ZodString, z.ZodString]>;
            refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
            response_key: z.ZodOptional<z.ZodString>;
            query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            refresh_button: z.ZodOptional<z.ZodBoolean>;
            control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
            timeout: z.ZodOptional<z.ZodNumber>;
            max_retries: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }>>;
        /** Whether the widget is a multi-select widget. */
        multi_select: z.ZodOptional<z.ZodObject<{
            placeholder: z.ZodOptional<z.ZodString>;
            chip: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }>>;
    }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        control_after_generate: z.ZodOptional<z.ZodBoolean>;
        image_upload: z.ZodOptional<z.ZodBoolean>;
        image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
        allow_batch: z.ZodOptional<z.ZodBoolean>;
        video_upload: z.ZodOptional<z.ZodBoolean>;
        options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
        remote: z.ZodOptional<z.ZodObject<{
            route: z.ZodUnion<[z.ZodString, z.ZodString]>;
            refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
            response_key: z.ZodOptional<z.ZodString>;
            query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            refresh_button: z.ZodOptional<z.ZodBoolean>;
            control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
            timeout: z.ZodOptional<z.ZodNumber>;
            max_retries: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }>>;
        /** Whether the widget is a multi-select widget. */
        multi_select: z.ZodOptional<z.ZodObject<{
            placeholder: z.ZodOptional<z.ZodString>;
            chip: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }>>;
    }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodLiteral<"COMBO">, z.ZodOptional<z.ZodObject<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        control_after_generate: z.ZodOptional<z.ZodBoolean>;
        image_upload: z.ZodOptional<z.ZodBoolean>;
        image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
        allow_batch: z.ZodOptional<z.ZodBoolean>;
        video_upload: z.ZodOptional<z.ZodBoolean>;
        options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
        remote: z.ZodOptional<z.ZodObject<{
            route: z.ZodUnion<[z.ZodString, z.ZodString]>;
            refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
            response_key: z.ZodOptional<z.ZodString>;
            query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            refresh_button: z.ZodOptional<z.ZodBoolean>;
            control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
            timeout: z.ZodOptional<z.ZodNumber>;
            max_retries: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }>>;
        /** Whether the widget is a multi-select widget. */
        multi_select: z.ZodOptional<z.ZodObject<{
            placeholder: z.ZodOptional<z.ZodString>;
            chip: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }>>;
    }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        control_after_generate: z.ZodOptional<z.ZodBoolean>;
        image_upload: z.ZodOptional<z.ZodBoolean>;
        image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
        allow_batch: z.ZodOptional<z.ZodBoolean>;
        video_upload: z.ZodOptional<z.ZodBoolean>;
        options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
        remote: z.ZodOptional<z.ZodObject<{
            route: z.ZodUnion<[z.ZodString, z.ZodString]>;
            refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
            response_key: z.ZodOptional<z.ZodString>;
            query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            refresh_button: z.ZodOptional<z.ZodBoolean>;
            control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
            timeout: z.ZodOptional<z.ZodNumber>;
            max_retries: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }>>;
        /** Whether the widget is a multi-select widget. */
        multi_select: z.ZodOptional<z.ZodObject<{
            placeholder: z.ZodOptional<z.ZodString>;
            chip: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }>>;
    }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, {
        control_after_generate: z.ZodOptional<z.ZodBoolean>;
        image_upload: z.ZodOptional<z.ZodBoolean>;
        image_folder: z.ZodOptional<z.ZodEnum<["input", "output", "temp"]>>;
        allow_batch: z.ZodOptional<z.ZodBoolean>;
        video_upload: z.ZodOptional<z.ZodBoolean>;
        options: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
        remote: z.ZodOptional<z.ZodObject<{
            route: z.ZodUnion<[z.ZodString, z.ZodString]>;
            refresh: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
            response_key: z.ZodOptional<z.ZodString>;
            query_params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            refresh_button: z.ZodOptional<z.ZodBoolean>;
            control_after_refresh: z.ZodOptional<z.ZodEnum<["first", "last"]>>;
            timeout: z.ZodOptional<z.ZodNumber>;
            max_retries: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }, {
            route: string;
            refresh?: number | undefined;
            response_key?: string | undefined;
            query_params?: Record<string, string> | undefined;
            refresh_button?: boolean | undefined;
            control_after_refresh?: "first" | "last" | undefined;
            timeout?: number | undefined;
            max_retries?: number | undefined;
        }>>;
        /** Whether the widget is a multi-select widget. */
        multi_select: z.ZodOptional<z.ZodObject<{
            placeholder: z.ZodOptional<z.ZodString>;
            chip: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }, {
            placeholder?: string | undefined;
            chip?: boolean | undefined;
        }>>;
    }>, z.ZodTypeAny, "passthrough">>>], null>, z.ZodTuple<[z.ZodEffects<z.ZodString, string, string>, z.ZodOptional<z.ZodObject<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        default: z.ZodOptional<z.ZodAny>;
        defaultInput: z.ZodOptional<z.ZodBoolean>;
        forceInput: z.ZodOptional<z.ZodBoolean>;
        tooltip: z.ZodOptional<z.ZodString>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        advanced: z.ZodOptional<z.ZodBoolean>;
        /** Backend-only properties. */
        rawLink: z.ZodOptional<z.ZodBoolean>;
        lazy: z.ZodOptional<z.ZodBoolean>;
    }, z.ZodTypeAny, "passthrough">>>], null>]>;

    declare const zKeybinding: z.ZodObject<{
        commandId: z.ZodString;
        combo: z.ZodObject<{
            key: z.ZodString;
            ctrl: z.ZodOptional<z.ZodBoolean>;
            alt: z.ZodOptional<z.ZodBoolean>;
            shift: z.ZodOptional<z.ZodBoolean>;
            meta: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            key: string;
            shift?: boolean | undefined;
            ctrl?: boolean | undefined;
            alt?: boolean | undefined;
            meta?: boolean | undefined;
        }, {
            key: string;
            shift?: boolean | undefined;
            ctrl?: boolean | undefined;
            alt?: boolean | undefined;
            meta?: boolean | undefined;
        }>;
        targetElementId: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        commandId: string;
        combo: {
            key: string;
            shift?: boolean | undefined;
            ctrl?: boolean | undefined;
            alt?: boolean | undefined;
            meta?: boolean | undefined;
        };
        targetElementId?: string | undefined;
    }, {
        commandId: string;
        combo: {
            key: string;
            shift?: boolean | undefined;
            ctrl?: boolean | undefined;
            alt?: boolean | undefined;
            meta?: boolean | undefined;
        };
        targetElementId?: string | undefined;
    }>;

    declare const zNodeId: z.ZodUnion<[z.ZodNumber, z.ZodString]>;

    export { }


declare global {
    const app: ComfyApp;
}

/// <reference types="vite/client" />

declare global {
  interface Window {
    __COMFYUI_FRONTEND_VERSION__: string
  }
}



/** ComfyUI extensions of litegraph */
declare module '@comfyorg/litegraph/dist/types/widgets' {
  interface IWidgetOptions {
    /** Currently used by DOM widgets only.  Declaring here reduces complexity. */
    onHide?: (widget: DOMWidget) => void
    /**
     * Controls whether the widget's value is included in the API workflow/prompt.
     * - If false, the value will be excluded from the API workflow but still serialized as part of the graph state
     * - If true or undefined, the value will be included in both the API workflow and graph state
     */
    serialize?: boolean
    /**
     * Rounding value for numeric float widgets.
     */
    round?: number
    /**
     * The minimum size of the node if the widget is present.
     */
    minNodeSize?: Size
    /**
     * Whether the widget is optional.
     */
    inputIsOptional?: boolean
    /**
     * Whether the widget is forced to be an input.
     */
    forceInput?: boolean
    /**
     * Whether the widget defaults to input state. Can still be converted back
     * to widget state.
     */
    defaultInput?: boolean
  }

  interface IBaseWidget {
    onRemove?: () => void
    beforeQueued?: () => unknown
    afterQueued?: () => unknown
    serializeValue?: (
      node: LGraphNode,
      index: number
    ) => Promise<unknown> | unknown

    /**
     * Refreshes the widget's value or options from its remote source.
     */
    refresh?: () => unknown

    /**
     * If the widget supports dynamic prompts, this will be set to true.
     * See extensions/core/dynamicPrompts.ts
     */
    dynamicPrompts?: boolean

    /**
     * Widget conversion fields
     */
    origType?: string
    origComputeSize?: (width: number) => Size
    origSerializeValue?: (
      node: LGraphNode,
      index: number
    ) => Promise<unknown> | unknown
  }
}



/**
 *  ComfyUI extensions of litegraph
 */
declare module '@comfyorg/litegraph' {
  interface LGraphNodeConstructor<T extends LGraphNode = LGraphNode> {
    type?: string
    comfyClass: string
    title: string
    nodeData?: ComfyNodeDefV1 & ComfyNodeDefV2
    category?: string
    new (): T
  }

  interface LGraphNode {
    constructor: LGraphNodeConstructor

    /**
     * Callback fired on each node after the graph is configured
     */
    onAfterGraphConfigured?(): void
    onGraphConfigured?(): void
    onExecuted?(output: any): void
    onNodeCreated?(this: LGraphNode): void
    /** @deprecated groupNode */
    setInnerNodes?(nodes: LGraphNode[]): void
    /** Originally a group node API. */
    getInnerNodes?(): LGraphNode[]
    /** @deprecated groupNode */
    convertToNodes?(): LGraphNode[]
    recreate?(): Promise<LGraphNode>
    refreshComboInNode?(defs: Record<string, ComfyNodeDef>)
    /** @deprecated groupNode */
    updateLink?(link: LLink): LLink | null
    /**
     * @deprecated primitive node.
     * Used by virtual nodes (primitives) to insert their values into the graph prior to queueing.
     * Externally used by
     * - https://github.com/pythongosssss/ComfyUI-Custom-Scripts/blob/bbda5e52ad580c13ceaa53136d9c2bed9137bd2e/web/js/presetText.js#L160-L182
     * - https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite/blob/4c7858ddd5126f7293dc3c9f6e0fc4c263cde079/web/js/VHS.core.js#L1889-L1889
     */
    applyToGraph?(extraLinks?: LLink[]): void
    onExecutionStart?(): unknown
    /**
     * Callback invoked when the node is dragged over from an external source, i.e.
     * a file or another HTML element.
     * @param e The drag event
     * @returns {boolean} True if the drag event should be handled by this node, false otherwise
     */
    onDragOver?(e: DragEvent): boolean
    /**
     * Callback invoked when the node is dropped from an external source, i.e.
     * a file or another HTML element.
     * @param e The drag event
     * @returns {boolean} True if the drag event should be handled by this node, false otherwise
     */
    onDragDrop?(e: DragEvent): Promise<boolean> | boolean

    index?: number
    runningInternalNodeId?: NodeId

    comfyClass?: string

    /**
     * If the node is a frontend only node and should not be serialized into the prompt.
     */
    isVirtualNode?: boolean

    addDOMWidget<
      T extends HTMLElement = HTMLElement,
      V extends object | string = string
    >(
      name: string,
      type: string,
      element: T,
      options?: DOMWidgetOptions<V>
    ): DOMWidget<T, V>

    animatedImages?: boolean
    imgs?: HTMLImageElement[]
    images?: ExecutedWsMessage['output']
    /** Container for the node's video preview */
    videoContainer?: HTMLElement
    /** Whether the node's preview media is loading */
    isLoading?: boolean
    /** The content type of the node's preview media */
    previewMediaType?: 'image' | 'video' | 'audio' | 'model'

    preview: string[]
    /** Index of the currently selected image on a multi-image node such as Preview Image */
    imageIndex?: number | null
    imageRects: Rect[]
    overIndex?: number | null
    pointerDown?: { index: number | null; pos: Point } | null
    /**
     * @deprecated No longer needed as we use {@link useImagePreviewWidget}
     */
    setSizeForImage?(force?: boolean): void
    /** @deprecated Unused */
    inputHeight?: unknown

    /** The y offset of the image preview to the top of the node body. */
    imageOffset?: number
    /** Callback for pasting an image file into the node */
    pasteFile?(file: File): void
    /** Callback for pasting multiple files into the node */
    pasteFiles?(files: File[]): void
  }
  /**
   * Only used by the Primitive node. Primitive node is using the widget property
   * to store/access the widget config.
   * We should remove this hacky solution once we have a proper solution.
   */
  interface INodeOutputSlot {
    widget?: IWidget
  }
}



/**
 * Extended types for litegraph, to be merged upstream once it has stabilized.
 */
declare module '@comfyorg/litegraph' {
  /**
   * widgets_values is set to LGraphNode by `LGraphNode.configure`, but it is not
   * used by litegraph internally. We should remove the dependency on it later.
   */
  interface LGraphNode {
    widgets_values?: unknown[]
  }
}