diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..aa527df --- /dev/null +++ b/.gitignore @@ -0,0 +1,203 @@ +# ---> Python +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +#build/ +develop-eggs/ +# dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +# ---> JS / TS + +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +# dist +dist-ssr +*.local +coverage + +# Editor directories and files +#.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? + +# yarn 2, see: https://yarnpkg.com/getting-started/qa#which-files-should-be-gitignored +.pnp.* +.yarn/* +!.yarn/patches +!.yarn/plugins +!.yarn/releases +!.yarn/sdks +!.yarn/versions + +# cooker folders +plugins + + diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 0000000..903d325 --- /dev/null +++ b/.prettierignore @@ -0,0 +1,9 @@ +coverage +public +dist +.yarn +yarn.lock + +web +src/py +# src/schema \ No newline at end of file diff --git a/.prettierrc.json b/.prettierrc.json new file mode 100644 index 0000000..94b9e4b --- /dev/null +++ b/.prettierrc.json @@ -0,0 +1,22 @@ +{ + "singleQuote": true, + "trailingComma": "all", + "semi": false, + "useTabs": true, + "tabWidth": 2, + "overrides": [ + { + "files": ["*.json", "*.jsonc"], + "options": { + "useTabs": false, + "trailingComma": "none" + } + }, + { + "files": ["*.json5"], + "options": { + "useTabs": false + } + } + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..8f9f76a --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,5 @@ +{ + "git.followTagsWhenSync": true, + "editor.formatOnSave": true, + "editor.defaultFormatter": "esbenp.prettier-vscode" +} diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..b82682f --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,27 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "type": "npm", + "script": "watch", + "group": { + "kind": "build", + "isDefault": true + }, + "problemMatcher": [], + "label": "npm: watch", + "detail": "tsc-watch -p tsconfig.json --onSuccess 'tsc-alias -p tsconfig.json -r build/replacers.js/mock.js'", + "runOptions": { + "runOn": "folderOpen" + } + }, + { + "type": "npm", + "script": "build", + "group": "build", + "problemMatcher": [], + "label": "npm: build", + "detail": "rimraf ./dist/js && tsc -p tsconfig.prod.json && tsc-alias -p tsconfig.prod.json -r build/replacers.js/mock.js" + } + ] +} diff --git a/.yarnrc.yml b/.yarnrc.yml new file mode 100644 index 0000000..3186f3f --- /dev/null +++ b/.yarnrc.yml @@ -0,0 +1 @@ +nodeLinker: node-modules diff --git a/ComfyLab-Pack.code-workspace b/ComfyLab-Pack.code-workspace new file mode 100644 index 0000000..362d7c2 --- /dev/null +++ b/ComfyLab-Pack.code-workspace @@ -0,0 +1,7 @@ +{ + "folders": [ + { + "path": "." + } + ] +} \ No newline at end of file diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..b960cd9 --- /dev/null +++ b/__init__.py @@ -0,0 +1,28 @@ +from pathlib import Path + +from .src.python.collection.collect_nodes import ( + import_all, + make_class_mappings, + make_display_name_mappings, + make_node_list, +) +from .src.python.collection.register_nodes import CATEGORY +from .src.python.shared.api import load_api + +import_all() + +NODE_CLASS_MAPPINGS = make_class_mappings() +NODE_DISPLAY_NAME_MAPPINGS = make_display_name_mappings() +make_node_list(Path(__file__).parent / 'node_list.json') + +load_api() + +print( + ' 🧬 {}: {} hybrid nodes successfully cloned'.format( + CATEGORY, len(NODE_CLASS_MAPPINGS) + ) +) + + +WEB_DIRECTORY = './dist/js' +__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS', 'WEB_DIRECTORY'] diff --git a/build/replacers.js/mock.js b/build/replacers.js/mock.js new file mode 100644 index 0000000..820a447 --- /dev/null +++ b/build/replacers.js/mock.js @@ -0,0 +1,20 @@ +/** + * Replace the paths within the '.mock' folder into the relative path expected at runtime. + * We use a RegExp to achieve this, could be another approach + */ +const re = /[^'"`]*\/\.mock\// +export default function mockReplacer({ + orig, + // file, + // config, +}) { + if (re.test(orig)) { + // console.log({ orig }) + // count the number of '..' before '.mock' folder + const nbParents = (orig.match(/\.\.\//g) || []).length + const replaced = orig.replace(re, '../'.repeat(3 + nbParents)) + // console.log({ replaced }) + return replaced + } + return orig +} diff --git a/build/replacers.js/mock.ts b/build/replacers.js/mock.ts new file mode 100644 index 0000000..a4b9536 --- /dev/null +++ b/build/replacers.js/mock.ts @@ -0,0 +1,23 @@ +import { AliasReplacerArguments } from 'tsc-alias' + +/** + * Replace the paths within the '.mock' folder into the relative path expected at runtime. + * We use a RegExp to achieve this, could be another approach + */ +const re = /[^'"`]*\/\.mock\// + +export default function mockReplacer({ + orig, + // file, + // config, +}: AliasReplacerArguments): string { + if (re.test(orig)) { + // console.log({ orig }) + // count the number of '..' before '.mock' folder + const nbParents = (orig.match(/\.\.\//g) || []).length + const replaced = orig.replace(re, '../'.repeat(3 + nbParents)) + // console.log({ replaced }) + return replaced + } + return orig +} diff --git a/build/replacers.js/tsconfig.replacers.json b/build/replacers.js/tsconfig.replacers.json new file mode 100644 index 0000000..a5d03a8 --- /dev/null +++ b/build/replacers.js/tsconfig.replacers.json @@ -0,0 +1,23 @@ +{ + "compilerOptions": { + "target": "ES2017", + "module": "NodeNext", + "lib": ["ES2017", "DOM"], + "skipLibCheck": true, + + "moduleResolution": "nodenext", + "removeComments": false, + + /* Linting */ + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true, + "noImplicitAny": true, + "strictNullChecks": true, + + "outDir": "./" + }, + "include": ["./*.ts"], + "exclude": [] +} diff --git a/dist/js/.mock/scripts/api.js b/dist/js/.mock/scripts/api.js new file mode 100644 index 0000000..cb0ff5c --- /dev/null +++ b/dist/js/.mock/scripts/api.js @@ -0,0 +1 @@ +export {}; diff --git a/dist/js/.mock/scripts/app.js b/dist/js/.mock/scripts/app.js new file mode 100644 index 0000000..cb0ff5c --- /dev/null +++ b/dist/js/.mock/scripts/app.js @@ -0,0 +1 @@ +export {}; diff --git a/dist/js/.mock/scripts/ui.js b/dist/js/.mock/scripts/ui.js new file mode 100644 index 0000000..cb0ff5c --- /dev/null +++ b/dist/js/.mock/scripts/ui.js @@ -0,0 +1 @@ +export {}; diff --git a/dist/js/.mock/scripts/ui/components/asyncDialog.js b/dist/js/.mock/scripts/ui/components/asyncDialog.js new file mode 100644 index 0000000..cb0ff5c --- /dev/null +++ b/dist/js/.mock/scripts/ui/components/asyncDialog.js @@ -0,0 +1 @@ +export {}; diff --git a/dist/js/.mock/scripts/widgets.js b/dist/js/.mock/scripts/widgets.js new file mode 100644 index 0000000..cb0ff5c --- /dev/null +++ b/dist/js/.mock/scripts/widgets.js @@ -0,0 +1 @@ +export {}; diff --git a/dist/js/custom.js b/dist/js/custom.js new file mode 100644 index 0000000..816fae0 --- /dev/null +++ b/dist/js/custom.js @@ -0,0 +1,287 @@ +import { slotShapes } from './shared/utils.js'; +const customLabels = { + XYPlotQueue: { + widget: { + max_dim1_per_page: 'dim1: max per page', + max_dim2_per_page: 'dim2: max per page', + }, + input: { + dim2: 'dim2 (opt)', + }, + output: { + dim1_value: 'dim1 value', + dim2_value: 'dim2 value', + xy_plot_data: 'XY plot data', + }, + }, + XYPlotRender: { + input: { + xy_plot_data: 'XY plot data', + plot_config_grid: 'config: grid (opt)', + plot_config_header: 'config: header (opt)', + plot_config_footer: 'config: footer (opt)', + }, + widget: { + dim1_header_format: 'dim1: header format', + dim2_header_format: 'dim2: header format', + }, + }, + PlotConfigGrid: { + widget: { + gap: 'gap (between cells)', + background_color: 'background color', + font_size: 'font size', + font_color: 'font color', + pad_col_headers: 'col headers: padding', + pad_row_headers: 'row headers: padding', + wrap_col_headers: 'col headers: wrap', + wrap_row_headers: 'row headers: wrap', + }, + output: { + plot_config_grid: 'config: grid', + }, + }, + PlotConfigHF: { + widget: { + text_left: 'text (left)', + text_center: 'text (center)', + text_right: 'text (right)', + background_color: 'background color', + font: 'font', + font_size: 'font size', + font_color: 'font color', + padding: 'padding', + }, + output: { + plot_config_hf: 'config: header / footer', + }, + }, + XYPlotDataSplit: { + input: { + xy_plot_data: 'XY plot data', + }, + output: { + current_page: 'current page', + total_pages: 'total pages', + }, + }, + ListFromMultiline: { + widget: { + strip_comments: 'strip comments', + }, + }, + ListFromFile: { + widget: { + file_path: 'path', + strip_comments: 'strip comments', + }, + }, + ListLimit: { + widget: { + nb_elements: 'nb of elements', + }, + }, + OutputConfigBackend: { + widget: { + file_path: 'JSON or YAML file (backend)', + show_config: 'show config', + error_display: 'display errors', + }, + }, + OutputConfigLocal: { + widget: { + error_display: 'display errors', + show_config: 'show config', + }, + }, + OutputConfigAuto: { + widget: { + auto_connect: 'auto-connect?', + multi_nodes: 'if multiple nodes found', + error_display: 'display errors', + show_config: 'show config', + }, + }, + NodeConfigApplyLocal: { + widget: { + error_display: 'display errors', + check_level: 'reject on', + }, + }, + MultiConfigFetch: { + widget: { + node_by: 'identify nodes by', + }, + }, + MultiConfigApplyLocal: { + widget: { + error_display: 'display errors', + check_level: 'reject on', + }, + }, + GenericQueue: { + input: { + input_list: 'input list', + }, + }, + FileQueue: { + widget: { + pattern: 'pattern(s)', + recursive: 'recursive?', + with_extension: 'with extension?', + }, + output: { + full_path: 'full path', + relative_path: 'relative path', + }, + }, + ImageQueue: { + widget: { + pattern: 'pattern(s)', + recursive: 'recursive?', + with_extension: 'with extension?', + }, + output: { + full_path: 'full path', + relative_path: 'relative path', + }, + }, + InputFolder: { + widget: { + path: 'folder path', + check_exists: 'check folder existence', + }, + }, + InputMultiline: { + widget: { + strip_comments: 'strip comments', + }, + }, + LoadImageRGBA: { + widget: { + with_extension: 'with extension?', + mask_precision: 'mask method', + }, + }, +}; +const customLooks = { + XYPlotQueue: { + input: { + dim1: { + shape: 'grid', + }, + dim2: { + shape: 'grid', + }, + }, + output: { + xy_plot_data: { + color_off: '#52395B', + color_on: '#9521c3', + }, + }, + }, + XYPlotRender: { + input: { + xy_plot_data: { + color_off: '#52395B', + color_on: '#9521c3', + }, + }, + }, + ListFromString: { + output: { + list: { shape: 'grid' }, + }, + }, + ListFromMultiline: { + output: { + list: { shape: 'grid' }, + }, + }, + ListFromFile: { + output: { + list: { shape: 'grid' }, + }, + }, + ListFromElements: { + output: { + list: { shape: 'grid' }, + }, + }, + ListMerge: { + output: { + list: { shape: 'grid' }, + }, + }, + ListLimit: { + output: { + list: { shape: 'grid' }, + }, + }, +}; +function setNodeLabels(nodeType, nodeData) { + const nodeName = nodeData.name; + if (!nodeName || !Object.keys(customLabels).includes(nodeName)) + return; + const original_onNodeCreated = nodeType.prototype.onNodeCreated; + nodeType.prototype.onNodeCreated = function (...args) { + const r = original_onNodeCreated.apply(this, args); + for (const [scope, scope_entry] of Object.entries(customLabels[nodeName])) { + for (const [name, label] of Object.entries(scope_entry)) { + let nodeItems = undefined; + switch (scope) { + case 'input': + nodeItems = this.inputs; + break; + case 'output': + nodeItems = this.outputs; + break; + case 'widget': + nodeItems = this.widgets; + break; + } + const item = nodeItems?.find((i) => i.name === name); + if (item) + item.label = label; + } + } + return r; + }; +} +function setNodeLooks(nodeType, nodeData) { + const nodeName = nodeData.name; + if (!nodeName || !Object.keys(customLooks).includes(nodeName)) + return; + const original_onNodeCreated = nodeType.prototype.onNodeCreated; + nodeType.prototype.onNodeCreated = function (...args) { + const r = original_onNodeCreated.apply(this, args); + for (const [scope, scope_entry] of Object.entries(customLooks[nodeName])) { + for (const [name, lookEntry] of Object.entries(scope_entry)) { + let nodeItems = undefined; + switch (scope) { + case 'input': + nodeItems = this.inputs; + break; + case 'output': + nodeItems = this.outputs; + break; + } + const item = nodeItems?.find((i) => i.name === name); + if (item) { + for (const [lookName, lookValue] of Object.entries(lookEntry)) { + if (lookName === 'shape') + item[lookName] = slotShapes[lookValue]; + else + item[lookName] = lookValue; + } + } + } + } + return r; + }; +} +export function customizeNode(nodeType, nodeData) { + setNodeLabels(nodeType, nodeData); + setNodeLooks(nodeType, nodeData); +} diff --git a/dist/js/nodes/config.js b/dist/js/nodes/config.js new file mode 100644 index 0000000..2ef5f84 --- /dev/null +++ b/dist/js/nodes/config.js @@ -0,0 +1,212 @@ +import { findWidget, ALL_CONFIG_FILE_TYPES, humanFileType, guessFileType, loadTextFile, retrievefile, forceMouseEvent, removeAllOutputs, } from '../shared/utils.js'; +import { makeTextWidget, makeButtonWidget, makeToggleWidget, makeSwitchWidget, } from '../widgets/factories.js'; +import { ERROR_DISPLAY } from '../widgets/misc.js'; +import { processOutputConfigLocal, } from '../shared/config.output.js'; +import { displaySingleError, displayErrorDict } from '../shared/error.js'; +async function processOutputResult(node, result, dataWidget, statusWidget, errorDisplay) { + if (!result) + return; + const title = node.title || node.type; + switch (result.success) { + case false: + dataWidget.value = {}; + statusWidget.label = result.error; + await displaySingleError(title, errorDisplay, result.error); + break; + case true: + dataWidget.value = result.data; + statusWidget.label = 'All outputs generated'; + break; + case 'partial': { + dataWidget.value = result.data; + const message = `${result.nbErrors} error${result.nbErrors > 1 ? 's' : ''} detected`; + statusWidget.label = message; + await displayErrorDict(title, errorDisplay, result.errors, message); + } + } +} +async function processOutputConfigUI(node, switchWidget, configWidget, dataWidget, statusWidget, errorDisplayWidget) { + let res; + await switchWidget.guard(async () => { + res = await processOutputConfigLocal(node, configWidget.value || undefined); + }); + const result = res; + if (!result || result.success === false) + configWidget.value = ''; + await processOutputResult(node, result, dataWidget, statusWidget, errorDisplayWidget.selected); + statusWidget.value = statusWidget.label; +} +export function OutputConfigBackend(nodeType) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated; + nodeType.prototype.onNodeCreated = function (...args) { + original_onNodeCreated?.apply(this, ...args); + const pathWidget = makeTextWidget(this, 'file_path', { + multiline: false, + placeholder: 'path to file (backend)', + default: '', + tooltip: 'full path to file (backend)', + }); + const retrieveButtonWidget = makeButtonWidget(this, 'retrieve', 'Retrieve output config', { + disabled: true, + tooltip: 'retrieve output config from a backend JSON or YAML file', + }); + const errorDisplayWidget = ERROR_DISPLAY(this); + const showConfigWidget = makeToggleWidget(this, 'show_config', { + default: true, + }); + const configWidget = makeTextWidget(this, 'config', { + multiline: true, + placeholder: 'output config', + default: '', + tooltip: 'output config as JSON or YAML', + disabled: true, + }); + const filenameWidget = makeTextWidget(this, 'filename', { + multiline: false, + disabled: true, + label: 'no file', + }); + const statusWidget = makeButtonWidget(this, 'status', 'No file selected', { + tooltip: 'status', + disabled: true, + }); + const switchWidget = makeSwitchWidget(this, 'switch', [configWidget]); + const dataWidget = findWidget(this, 'data'); + pathWidget.callback = (text) => { + retrieveButtonWidget.disabled = !text; + }; + showConfigWidget.callback = (value) => { + switchWidget.switch(value); + }; + retrieveButtonWidget.callback = async () => { + filenameWidget.label = 'no file'; + filenameWidget.value = ''; + configWidget.value = ''; + statusWidget.label = 'Retrieving file...'; + try { + const retrieved = await retrievefile(pathWidget.value); + filenameWidget.label = `file: (${humanFileType(retrieved.mime)})`; + filenameWidget.value = retrieved.filename; + configWidget.value = retrieved.content; + await processOutputConfigUI(this, switchWidget, configWidget, dataWidget, statusWidget, errorDisplayWidget); + } + catch (e) { + statusWidget.label = e.message; + dataWidget.value = {}; + await switchWidget.guard(async () => { + removeAllOutputs(this); + for (const w of this.widgets) { + delete w.y; + delete w.last_y; + } + }); + await displaySingleError(this.title || this.type, errorDisplayWidget.selected, e.message); + } + finally { + forceMouseEvent(); + } + }; + }; + const original_onConfigure = nodeType.prototype.onConfigure; + nodeType.prototype.onConfigure = function (...args) { + original_onConfigure?.apply(this, ...args); + console.log('OutputConfigBackend / onConfigure'); + const statusWidget = findWidget(this, 'status'); + if (statusWidget.value) + statusWidget.label = statusWidget.value; + const filenameWidget = findWidget(this, 'filename'); + filenameWidget.label = 'no file'; + if (filenameWidget.value) { + const ext = filenameWidget.value.split('.').pop(); + if (ext === 'json') + filenameWidget.label = 'file: (json)'; + else if (['yml', 'yaml'].includes(ext)) + filenameWidget.label = 'file: (yaml)'; + else + filenameWidget.label = 'file:'; + } + const retrieveButtonWidget = findWidget(this, 'retrieve'); + const pathWidget = findWidget(this, 'file_path'); + retrieveButtonWidget.disabled = !pathWidget.value; + const showConfigWidget = findWidget(this, 'show_config'); + if (!showConfigWidget.value) + showConfigWidget.callback(false); + }; +} +export function OutputConfigLocal(nodeType) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated; + nodeType.prototype.onNodeCreated = function (...args) { + original_onNodeCreated?.apply(this, ...args); + const loadButtonWidget = makeButtonWidget(this, 'load', 'Load output config', { + tooltip: 'load output config from a local JSON or YAML file', + }); + const errorDisplayWidget = ERROR_DISPLAY(this); + const showConfigWidget = makeToggleWidget(this, 'show_config', { + default: true, + }); + const configWidget = makeTextWidget(this, 'config', { + multiline: true, + placeholder: 'output config', + default: '', + tooltip: 'output config as JSON or YAML', + disabled: true, + }); + const filenameWidget = makeTextWidget(this, 'filename', { + multiline: false, + disabled: true, + label: 'no file', + }); + const statusWidget = makeButtonWidget(this, 'status', 'No file selected', { + tooltip: 'status', + disabled: true, + }); + const switchWidget = makeSwitchWidget(this, 'switch', [configWidget]); + const dataWidget = findWidget(this, 'data'); + showConfigWidget.callback = (value) => { + switchWidget.switch(value); + }; + loadButtonWidget.callback = async () => { + try { + const loaded = await loadTextFile(ALL_CONFIG_FILE_TYPES); + if (loaded) { + filenameWidget.label = `file: (${humanFileType(loaded.type)})`; + filenameWidget.value = loaded.name; + configWidget.value = loaded.content; + } + else { + return; + } + } + catch (e) { + statusWidget.label = e.message; + configWidget.value = ''; + dataWidget.value = {}; + await switchWidget.guard(async () => { + removeAllOutputs(this); + for (const w of this.widgets) { + delete w.y; + delete w.last_y; + } + }); + await displaySingleError(this.title || this.type, errorDisplayWidget.selected, 'Content is not JSON or YAML'); + return; + } + await processOutputConfigUI(this, switchWidget, configWidget, dataWidget, statusWidget, errorDisplayWidget); + }; + }; + const original_onConfigure = nodeType.prototype.onConfigure; + nodeType.prototype.onConfigure = function (...args) { + original_onConfigure?.apply(this, ...args); + const statusWidget = findWidget(this, 'status'); + if (statusWidget.value) + statusWidget.label = statusWidget.value; + const filenameWidget = findWidget(this, 'filename'); + filenameWidget.label = 'no file'; + if (filenameWidget.value) { + filenameWidget.label = guessFileType(filenameWidget.value); + } + const showConfigWidget = findWidget(this, 'show_config'); + if (!showConfigWidget.value) + showConfigWidget.callback(false); + }; +} diff --git a/dist/js/nodes/debug.js b/dist/js/nodes/debug.js new file mode 100644 index 0000000..b03492c --- /dev/null +++ b/dist/js/nodes/debug.js @@ -0,0 +1,86 @@ +import { loadTextFile } from '../shared/utils.js'; +import { makeTextWidget, makeButtonWidget, makeToggleWidget, makeSwitchWidget, } from '../widgets/factories.js'; +import { parseConfig } from '../shared/config.common.js'; +import { log } from '../shared/common.js'; +export function DebugJSONYAML(nodeType) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated; + nodeType.prototype.onNodeCreated = function (...args) { + original_onNodeCreated?.apply(this, ...args); + const loadButtonWidget = makeButtonWidget(this, 'load', 'Load file', { + tooltip: 'load a JSON or YAML file', + }); + const fileTypeWidget = makeTextWidget(this, 'file_type', { + multiline: false, + placeholder: '', + default: 'unknown', + tooltip: 'content type as detected on file load', + }); + fileTypeWidget.disabled = true; + const contentWidget = makeTextWidget(this, 'content', { + multiline: true, + placeholder: 'loaded content', + default: '{}', + tooltip: 'loaded content', + }); + const parsedTypeWidget = makeTextWidget(this, 'parsed_type', { + multiline: false, + placeholder: '', + default: 'unknown', + tooltip: 'content type as detected on parse', + }); + parsedTypeWidget.disabled = true; + loadButtonWidget.callback = async () => { + fileTypeWidget.value = 'unknown'; + parsedTypeWidget.value = 'unknown'; + const loaded = await loadTextFile('.json,.yaml,.yml,application/JSON,application/yaml'); + if (loaded) { + fileTypeWidget.value = loaded.type; + try { + const parsed = await parseConfig(loaded.content); + parsedTypeWidget.value = parsed.type; + contentWidget.value = parsed.prettified; + } + catch (e) { + parsedTypeWidget.value = e.message; + contentWidget.value = ''; + } + } + this.setDirtyCanvas(true); + }; + }; +} +export function DebugWidgetVisibility(nodeType) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated; + nodeType.prototype.onNodeCreated = function (...args) { + original_onNodeCreated?.apply(this, ...args); + makeButtonWidget(this, 'button1', 'a button', {}); + const showWidget = makeToggleWidget(this, 'show', { + default: true, + }); + const multi1Widget = makeTextWidget(this, 'multiline1', { + multiline: true, + default: 'multiline1', + }); + const text1Widget = makeTextWidget(this, 'text1', { + multiline: false, + default: 'string #1', + }); + const text2Widget = makeTextWidget(this, 'text2', { + multiline: false, + default: 'string #2', + }); + const multi2Widget = makeTextWidget(this, 'multiline2', { + multiline: true, + default: 'multiline2', + }); + makeTextWidget(this, 'footer', { + multiline: false, + default: 'footer', + }); + const switchWidget = makeSwitchWidget(this, 'switch', [multi1Widget, text1Widget], [text2Widget, multi2Widget]); + showWidget.callback = (value) => { + switchWidget.switch(value); + log.debug('switch value', switchWidget.value); + }; + }; +} diff --git a/dist/js/nodes/input.js b/dist/js/nodes/input.js new file mode 100644 index 0000000..8cd499c --- /dev/null +++ b/dist/js/nodes/input.js @@ -0,0 +1,15 @@ +import { findWidget, loadTextFile } from '../shared/utils.js'; +export function InputMultiline(nodeType) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated; + nodeType.prototype.onNodeCreated = function (...args) { + original_onNodeCreated?.apply(this, ...args); + const loadButtonWidget = findWidget(this, 'load'); + const textWidget = findWidget(this, 'multiline'); + loadButtonWidget.callback = async () => { + const loaded = await loadTextFile('text/*'); + if (loaded) { + textWidget.value = loaded.content; + } + }; + }; +} diff --git a/dist/js/nodes/list.js b/dist/js/nodes/list.js new file mode 100644 index 0000000..603db2a --- /dev/null +++ b/dist/js/nodes/list.js @@ -0,0 +1,15 @@ +import { findWidget, loadTextFile } from '../shared/utils.js'; +export function ListFromMultiline(nodeType) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated; + nodeType.prototype.onNodeCreated = function (...args) { + original_onNodeCreated?.apply(this, ...args); + const loadButtonWidget = findWidget(this, 'load'); + const textWidget = findWidget(this, 'multiline'); + loadButtonWidget.callback = async () => { + const loaded = await loadTextFile('text/*'); + if (loaded) { + textWidget.value = loaded.content; + } + }; + }; +} diff --git a/dist/js/register.js b/dist/js/register.js new file mode 100644 index 0000000..b617f44 --- /dev/null +++ b/dist/js/register.js @@ -0,0 +1,68 @@ +import { app } from '../../../scripts/app.js'; +import { CATEGORY } from './shared/common.js'; +import { customizeNode } from './custom.js'; +import { setupDynamicConnections } from './shared/dynamic_connections.js'; +import { QUEUE_STATUS } from './widgets/queue.js'; +import { HIDDEN, BTN, ERROR_DISPLAY } from './widgets/misc.js'; +import { OutputConfigBackend, OutputConfigLocal } from './nodes/config.js'; +import { ListFromMultiline } from './nodes/list.js'; +import { InputMultiline } from './nodes/input.js'; +import { DebugJSONYAML, DebugWidgetVisibility } from './nodes/debug.js'; +globalThis[CATEGORY] = { log: 'debug' }; +app.registerExtension({ + name: 'ComfyLab.pack', + async beforeRegisterNodeDef(nodeType, nodeData) { + if (nodeData?.category?.split('/')[0] !== CATEGORY) { + return; + } + switch (nodeData.name) { + case 'ListMerge': + setupDynamicConnections(nodeType, 'list', 'LIST', { + separator: ' ', + start_index: 1, + }); + break; + case 'ListFromElements': + setupDynamicConnections(nodeType, 'element', '*', { + separator: ' ', + start_index: 1, + }); + break; + case 'InputMultiline': + InputMultiline(nodeType); + break; + case 'FormatString': + case 'FormatMultiline': + setupDynamicConnections(nodeType, 'arg', 'STRING,INT,FLOAT,BOOLEAN', { + separator: '', + start_index: 0, + }); + break; + case 'ListFromMultiline': + ListFromMultiline(nodeType); + break; + case 'DebugJSONYAML': + DebugJSONYAML(nodeType); + break; + case 'DebugWidgetVisibility': + DebugWidgetVisibility(nodeType); + break; + case 'OutputConfigBackend': + OutputConfigBackend(nodeType); + break; + case 'OutputConfigLocal': + OutputConfigLocal(nodeType); + break; + } + customizeNode(nodeType, nodeData); + return nodeType; + }, + getCustomWidgets() { + return { + QUEUE_STATUS, + HIDDEN, + BTN, + ERROR_DISPLAY, + }; + }, +}); diff --git a/dist/js/shared/common.js b/dist/js/shared/common.js new file mode 100644 index 0000000..6959bcd --- /dev/null +++ b/dist/js/shared/common.js @@ -0,0 +1,55 @@ +export const CATEGORY = 'ComfyLab'; +const logLevels = { + success: { level: 0, console: 'info', emoji: '👍' }, + error: { level: 1, console: 'error', emoji: undefined }, + warn: { level: 2, console: 'warn', emoji: undefined }, + info: { level: 3, console: 'info', emoji: 'ℹ️' }, + debug: { level: 4, console: 'debug', emoji: undefined }, +}; +const logger = (levelType, ...args) => { + const gt = globalThis; + if (gt[CATEGORY]?.debug || + (gt[CATEGORY]?.log && + logLevels[gt[CATEGORY].log].level >= logLevels[levelType].level)) { + const level = gt[CATEGORY]?.debug + ? logLevels['debug'] + : logLevels[levelType]; + if (level.emoji) + console[level.console](level.emoji, ...args); + else + console[level.console](...args); + } +}; +export const isObject = (variable) => { + const check = Object(variable); + return (check && + variable === check && + typeof variable !== 'function' && + !Array.isArray(check)); +}; +export const inspect = (variable) => { + if (isObject(variable)) { + for (const [name, val] of Object.entries(variable)) { + console.log(`${name}: `, val); + } + } + else { + console.log(variable); + } +}; +export const log = { + success: (...args) => logger('success', `${CATEGORY}:`, ...args), + error: (...args) => logger('error', `${CATEGORY}:`, ...args), + warn: (...args) => logger('warn', `${CATEGORY}:`, ...args), + info: (...args) => logger('info', `${CATEGORY}:`, ...args), + debug: (...args) => logger('debug', ...args), + sep: () => { + console.log('---------------------------------'); + }, + inspect, +}; +export const success = log.success; +export const error = log.error; +export const warn = log.warn; +export const info = log.info; +export const debug = log.debug; diff --git a/dist/js/shared/config.common.js b/dist/js/shared/config.common.js new file mode 100644 index 0000000..328455f --- /dev/null +++ b/dist/js/shared/config.common.js @@ -0,0 +1,4 @@ +import { fetchApi } from './utils.js'; +export async function parseConfig(raw) { + return await fetchApi('config_parse', 'POST', { raw }); +} diff --git a/dist/js/shared/config.output.js b/dist/js/shared/config.output.js new file mode 100644 index 0000000..a5024fb --- /dev/null +++ b/dist/js/shared/config.output.js @@ -0,0 +1,144 @@ +import { isObject } from './common.js'; +import { guessOutputType, compatibleTypes } from './types.js'; +import { fetchApi, slotShapes, removeAllOutputs } from './utils.js'; +export async function processOutputConfigLocal(node, config) { + let body = {}; + let data = {}; + if (config) { + try { + body = await fetchApi('config_validate', 'POST', { + raw: config, + schema: 'config.output', + }); + } + catch (error) { + removeAllOutputs(node); + return { + success: false, + error: error.message, + }; + } + data = body.data; + } + const apiErrors = body.errors || []; + const errors = {}; + for (const [errorScope, errorType] of apiErrors) { + if (!Object.keys(errors).includes(errorScope[0])) + errors[errorScope[0]] = {}; + errors[errorScope[0]][errorScope[1]] = errorType; + } + if (Object.keys(data).length === 0) { + removeAllOutputs(node); + return { + success: false, + error: 'No data', + }; + } + const parsed = new Map(); + for (const [k, entry] of Object.entries(data)) { + if (Object.keys(errors).includes(k)) + continue; + const key = String(k); + let value, type; + const extra_info = {}; + if (!isObject(entry)) { + value = entry; + type = guessOutputType(value); + } + else { + const entryObj = entry; + value = entryObj['value']; + if (Object.keys(entryObj).includes('type')) { + type = entryObj['type']; + } + else { + type = guessOutputType(value); + } + for (const extra of ['label', 'tooltip', 'color_on', 'color_off']) { + if (Object.keys(entryObj).includes(extra)) + extra_info[extra] = entryObj[extra]; + } + if (entryObj.shape && Object.keys(slotShapes).includes(entryObj.shape)) + extra_info.shape = slotShapes[entryObj.shape]; + } + if (!extra_info.shape && type === 'LIST') + extra_info.shape = slotShapes['grid']; + parsed.set(key, { + value, + type, + extra_info, + }); + } + const existingLinks = {}; + while (node.outputs?.length > 0) { + const output = node.outputs[0]; + const entry = parsed.get(output.name); + if (entry && + compatibleTypes(entry.type, output.type) && + entry.extra_info.label === output.label && + output.links && + output.links.length) { + const links = []; + for (const l of output.links) { + const link = node.graph.links.get(l); + if (link) + links.push(link); + } + if (links.length) + existingLinks[output.name] = links; + } + node.removeOutput(0); + } + for (const [name, entry] of parsed.entries()) { + node.addOutput(name, entry.type, entry.extra_info); + const links = existingLinks[name]; + if (links) { + for (const link of links) { + const targetNode = node.graph._nodes_by_id[link.target_id]; + node.connect(name, targetNode, link.target_slot); + } + } + } + const errorLabels = {}; + let nbErrors = 0; + for (const [output, props] of Object.entries(errors)) { + errorLabels[output] = []; + for (const [prop, errorType] of Object.entries(props)) { + nbErrors++; + if (errorType === 'required') { + errorLabels[output].push(`'${prop}' is required`); + continue; + } + let label = `'${prop}' `; + switch (prop) { + case 'type': + label += 'should be a string, or a list of strings'; + break; + case 'label': + case 'tooltip': + case 'color_off': + case 'color_on': + label += 'should be a string'; + break; + case 'shape': + label += "should be one of: 'box', 'circle', 'arrow', 'grid'"; + break; + } + errorLabels[output].push(label); + } + } + if (nbErrors === 0) + return { + success: true, + data: Object.fromEntries(parsed), + applied: true, + }; + else + return { + success: 'partial', + data: Object.fromEntries(parsed), + nbErrors, + errors: errorLabels, + applied: true, + }; +} diff --git a/dist/js/shared/dynamic_connections.js b/dist/js/shared/dynamic_connections.js new file mode 100644 index 0000000..dc94f6a --- /dev/null +++ b/dist/js/shared/dynamic_connections.js @@ -0,0 +1,153 @@ +import { app } from '../../../../scripts/app.js'; +export const nodesFromLink = (node, link) => { + const fromNode = app.graph.getNodeById(link.origin_id); + const toNode = app.graph.getNodeById(link.target_id); + let tp = 'error'; + if (fromNode.id === node.id) { + tp = 'outgoing'; + } + else if (toNode.id === node.id) { + tp = 'incoming'; + } + return { to: toNode, from: fromNode, type: tp }; +}; +export const setupDynamicConnections = (nodeType, prefix, inputType, opts = undefined) => { + const options = Object.assign({ + separator: '_', + start_index: 1, + }, opts || {}); + const onNodeCreated = nodeType.prototype.onNodeCreated; + const inputList = typeof inputType === 'object'; + nodeType.prototype.onNodeCreated = function () { + const r = onNodeCreated ? onNodeCreated.apply(this, []) : undefined; + this.addInput(`${prefix}${options.separator}${options.start_index}`, inputList ? '*' : inputType); + return r; + }; + const onConnectionsChange = nodeType.prototype.onConnectionsChange; + nodeType.prototype.onConnectionsChange = function (...args) { + const [type, slotIndex, isConnected, link, ioSlot] = args; + options.link = link; + options.ioSlot = ioSlot; + const r = onConnectionsChange + ? onConnectionsChange.apply(this, [ + type, + slotIndex, + isConnected, + link, + ioSlot, + ]) + : undefined; + options.DEBUG = { + node: this, + type, + slotIndex, + isConnected, + link, + ioSlot, + }; + const oldSize = [this.size[0], this.size[1]]; + const oldComputedSize = this.computeSize(); + dynamicConnection(this, slotIndex, isConnected, `${prefix}${options.separator}`, inputType, options); + for (const widget of this.widgets || []) { + delete widget.y; + delete widget.last_y; + delete widget.computedHeight; + } + const newComputedSize = this.computeSize(); + this.setSize([ + oldSize[0], + oldSize[1] + newComputedSize[1] - oldComputedSize[1], + ]); + return r; + }; +}; +export const dynamicConnection = (node, index, connected, connectionPrefix = 'input_', connectionType = '*', opts = undefined) => { + const options = Object.assign({ + start_index: 1, + }, opts || {}); + const isDynamicInput = (inputName) => inputName.startsWith(connectionPrefix); + if (node.inputs.length > 0 && !isDynamicInput(node.inputs[index].name)) { + return; + } + const listConnection = typeof connectionType === 'object'; + const conType = listConnection ? '*' : connectionType; + const nameArray = options.nameArray || []; + const clean_inputs = () => { + if (node.inputs.length === 0) + return; + let i_count = node.inputs?.length || 0; + const to_remove = []; + for (let n = 1; n < node.inputs.length; n++) { + const element = node.inputs[n]; + if (!element.link && isDynamicInput(element.name)) { + if (node.widgets) { + const w = node.widgets.find((w) => w.name === element.name); + if (w) { + w.onRemoved?.(); + node.widgets.length = node.widgets.length - 1; + } + } + to_remove.push(n); + } + } + for (let i = 0; i < to_remove.length; i++) { + const id = to_remove[i]; + node.removeInput(id); + i_count -= 1; + } + node.inputs.length = i_count; + i_count = node.inputs?.length || 0; + let prefixed_idx = options.start_index; + for (let i = 0; i < node.inputs.length; i++) { + let name = ''; + if (isDynamicInput(node.inputs[i].name)) { + name = `${connectionPrefix}${prefixed_idx}`; + prefixed_idx += 1; + } + else { + name = node.inputs[i].name; + } + if (nameArray.length > 0) { + name = i < nameArray.length ? nameArray[i] : name; + } + node.inputs[i].label = node.inputs[i].label || name; + node.inputs[i].name = name; + } + }; + if (!connected) { + if (!options.link) { + clean_inputs(); + } + else { + if (!options.ioSlot.link) { + node.connectionTransit = true; + } + else { + node.connectionTransit = false; + clean_inputs(); + } + } + } + if (connected) { + if (options.link) { + const link = nodesFromLink(node, options.link); + if (link.type === 'outgoing') + return; + } + else { + } + if (node.connectionTransit) { + node.connectionTransit = false; + } + clean_inputs(); + if (node.inputs.length === 0) + return; + if (node.inputs[node.inputs.length - 1].link !== null) { + const nextIndex = node.inputs.reduce((acc, cur) => isDynamicInput(cur.name) ? ++acc : acc, 0); + const name = nextIndex < nameArray.length + ? nameArray[nextIndex] + : `${connectionPrefix}${nextIndex + options.start_index}`; + node.addInput(name, conType); + } + } +}; diff --git a/dist/js/shared/error.js b/dist/js/shared/error.js new file mode 100644 index 0000000..899080d --- /dev/null +++ b/dist/js/shared/error.js @@ -0,0 +1,77 @@ +import { $el } from '../../../../scripts/ui.js'; +import { log } from '../shared/common.js'; +import { showErrorDialog } from '../shared/utils.js'; +export async function displaySingleError(nodeTitle, errorDisplay, token1, token2 = '', displayTitle = true, displayCategory = true) { + let message = ''; + switch (errorDisplay) { + case 'browser': + message = token2 ? `${token1}: ${token2}` : token1; + if (displayTitle) + log.warn(`${nodeTitle}: ${message}`); + else if (displayCategory) + log.warn(message); + else + console.warn(message); + break; + case 'dialog': + message = token2 ? `${token1}: ${token2}` : token1; + if (displayTitle) + await showErrorDialog({ + title: nodeTitle, + subtitle: '⚠️ ' + message, + centerSubtitle: true, + }); + else + await showErrorDialog({ + subtitle: '⚠️ ' + message, + centerSubtitle: true, + }); + break; + default: + } +} +export async function displayErrorDict(nodeTitle, errorDisplay, errorDict, message = '') { + switch (errorDisplay) { + case 'browser': + if (message) { + await displaySingleError(nodeTitle, errorDisplay, message + ':'); + } + for (const [key, err] of Object.entries(errorDict)) { + const errors = Array.isArray(err) ? err : [err]; + for (const error of errors) { + if (message) + await displaySingleError(nodeTitle, errorDisplay, ` - '${key}'`, String(error), false, false); + else + await displaySingleError(nodeTitle, errorDisplay, `Error in '${key}'`, String(error)); + } + } + break; + case 'dialog': { + const allErrors = []; + for (const [key, errors] of Object.entries(errorDict)) { + if (Array.isArray(errors)) { + const keyErrors = []; + for (const error of errors) { + keyErrors.push($el('li', String(error))); + } + allErrors.push($el('li', [ + key + ':', + $el('ul', { style: { paddingLeft: '20px' } }, keyErrors), + ])); + } + else { + allErrors.push($el('li', [`'${key}': ${String(errors)}`])); + } + } + await showErrorDialog({ + title: nodeTitle, + subtitle: '⚠️ ' + message, + centerSubtitle: true, + content: $el('ul', { style: { margin: '0px', paddingLeft: '0px' } }, allErrors), + centerContent: true, + }); + break; + } + default: + } +} diff --git a/dist/js/shared/types.js b/dist/js/shared/types.js new file mode 100644 index 0000000..f25fe6d --- /dev/null +++ b/dist/js/shared/types.js @@ -0,0 +1,28 @@ +export function guessOutputType(value) { + if (Array.isArray(value)) + return 'LIST'; + else if (typeof value === 'number') { + return Number.isInteger(value) ? ['INT', 'FLOAT'] : 'FLOAT'; + } + else if (typeof value === 'bigint') + return 'INT'; + else if (typeof value === 'string') + return 'STRING'; + else if (typeof value === 'boolean') + return 'BOOLEAN'; + else + return '*'; +} +export function compatibleTypes(type1, type2) { + if (!Array.isArray(type1) && !Array.isArray(type2)) + return type1 === type2; + const t1 = Array.isArray(type1) ? type1 : [type1]; + const t2 = Array.isArray(type2) ? type2 : [type2]; + if (t1.length !== t2.length) + return false; + for (const val of t1) { + if (!t2.includes(val)) + return false; + } + return true; +} diff --git a/dist/js/shared/utils.js b/dist/js/shared/utils.js new file mode 100644 index 0000000..fac32cc --- /dev/null +++ b/dist/js/shared/utils.js @@ -0,0 +1,240 @@ +import { api } from '../../../../scripts/api.js'; +import { $el } from '../../../../scripts/ui.js'; +import { ComfyAsyncDialog } from '../../../../scripts/ui/components/asyncDialog.js'; +export const findWidget = (node, name) => { + return node.widgets?.find((w) => w.name === name); +}; +export const findWidgetIndex = (node, name) => { + return node.widgets?.findIndex((w) => w.name === name); +}; +export const findInput = (node, name) => { + return node.inputs?.find((i) => i.name === name); +}; +export const findWidgetOrInput = (node, name) => { + return findWidget(node, name) || findInput(node, name); +}; +export const findOutput = (node, name) => { + return node.outputs?.find((o) => o.name === name); +}; +export const removeWidget = (node, name) => { + const index = findWidgetIndex(node, name); + if (index && index >= 0) { + const widget = node.widgets[index]; + node.widgets.splice(index, 1); + widget?.onRemove(); + node.size = node.computeSize(); + node.setDirtyCanvas(true, true); + return true; + } + else + return false; +}; +export function removeAllOutputs(node) { + while (node.outputs?.length > 0) { + node.removeOutput(0); + } +} +export function lookupNodes(key, by, except) { + let modes = []; + if (!by) + modes = ['id', 'title', 'type']; + else if (Array.isArray(by)) + modes = by; + else + modes = [by]; + const strKey = String(key); + const found = new Set(); + for (const mode of modes) { + if (mode === 'id' && !isNaN(+strKey) && Number.isInteger(+strKey)) { + const node = app.graph._nodes_by_id[+strKey]; + if (node && node !== except) + found.add(node); + } + else { + for (const node of app.graph._nodes) { + if (node[mode] === strKey && node !== except) + found.add(node); + } + } + } + return Array.from(found); +} +export const slotShapes = { + box: 1, + circle: 3, + arrow: 5, + grid: 6, +}; +class ConfigError extends Error { +} +export async function fetchApi(entry, method, params) { + const response = await api.fetchApi('/comfylab/' + entry, { + method, + body: JSON.stringify(params), + }); + if (!response.ok) { + switch (response.status) { + case 404: + throw new ConfigError('File not found'); + case 415: + throw new ConfigError(response.statusText); + case 500: + throw new ConfigError(`Internal error: ${response.statusText}`); + default: + throw new ConfigError(response.statusText); + } + } + return await response.json(); +} +export async function retrievefile(path) { + const body = await fetchApi('load_file', 'POST', { path }); + return { + filename: body.filename, + content: body.content, + mime: body.mime, + encoding: body.encoding, + }; +} +export function saveToTextFile(filename, content, accept = 'text/plain') { + const blob = new Blob([content], { type: accept + ';charset=utf-8' }), anchor = document.createElement('a'); + anchor.download = filename; + anchor.href = (window.webkitURL || window.URL).createObjectURL(blob); + anchor.dataset.downloadurl = [accept, anchor.download, anchor.href].join(':'); + anchor.click(); + anchor.remove(); +} +export async function loadTextFile(accept = 'text/plain') { + return new Promise((resolve) => { + const input = document.createElement('input'); + input.type = 'file'; + input.accept = accept; + input.style.display = 'none'; + const reader = new FileReader(); + let name = undefined; + let contentType = undefined; + reader.addEventListener('load', () => { + resolve({ + content: reader.result, + name: name, + type: contentType, + }); + }, { once: true }); + reader.addEventListener('abort', () => { + resolve(undefined); + }, { once: true }); + reader.addEventListener('error', () => { + resolve(undefined); + }, { once: true }); + input.addEventListener('change', (e) => { + const target = e.target; + if (target.files) { + const file = target.files[0]; + name = file.name; + contentType = file.type; + reader.readAsText(file); + } + else + resolve(undefined); + }, { once: true }); + input.addEventListener('cancel', () => { + resolve(undefined); + }, { once: true }); + input.click(); + input.remove(); + }); +} +export async function showErrorDialog({ title = '', subtitle = '', centerSubtitle = false, content = [], centerContent = false, }) { + const elements = []; + if (title) { + elements.push($el('div', { + style: { + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + color: '#8c8c8c', + }, + }, [$el('h3', title)])); + } + if (subtitle) { + let subtitleEl = $el('h4', subtitle); + if (centerSubtitle) { + subtitleEl = $el('div', { + style: { + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + }, + }, [subtitleEl]); + } + elements.push(subtitleEl); + } + if (content) { + if (!Array.isArray(content)) + content = [content]; + if (centerContent) { + content = [ + $el('div', { + style: { + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + }, + }, content), + ]; + } + elements.push(...content); + } + const dialog = new ComfyAsyncDialog(); + const res = await dialog.showModal(elements); + dialog.element.remove(); + return res; +} +export function forceMouseEvent() { + app.canvas.processMouseUp(new MouseEvent('mouseup')); +} +export function makeWidgetAsync(widget) { + if (widget._event) + return; + widget._event = { + target: new EventTarget(), + callback: widget.callback, + }; + delete widget.callback; + widget._event.target.addEventListener('change', async (ev) => { + if (widget._event.callback) { + await widget._event.callback(ev.detail); + } + }); + Object.defineProperty(widget, 'callback', { + get() { + return (value) => { + widget._event.target.dispatchEvent(new CustomEvent('change', { detail: value })); + }; + }, + set(cb) { + widget._event.callback = cb; + }, + enumerable: true, + }); +} +export const ALL_CONFIG_FILE_TYPES = '.json,.jsonc,.json5,.yaml,.yml,application/JSON,application/json5,application/yaml'; +export const humanFileType = (mimeType) => { + mimeType = mimeType.toLowerCase(); + if (mimeType.includes('json5')) + return 'json5'; + if (mimeType.includes('json')) + return 'json'; + if (mimeType.includes('yaml')) + return 'yaml'; + return ''; +}; +export const guessFileType = (filename) => { + const ext = filename.split('.').pop() || ''; + if (ext === 'json5') + return 'file: (json5)'; + if (ext === 'json' || ext === 'jsonc') + return 'file: (json)'; + else if (['yml', 'yaml'].includes(ext)) + return 'file: (yaml)'; + return 'file:'; +}; diff --git a/dist/js/widgets/factories.js b/dist/js/widgets/factories.js new file mode 100644 index 0000000..3f696ca --- /dev/null +++ b/dist/js/widgets/factories.js @@ -0,0 +1,205 @@ +import { app } from '../../../../scripts/app.js'; +import { ComfyWidgets } from '../../../../scripts/widgets.js'; +import { findWidget, makeWidgetAsync } from '../shared/utils.js'; +export function makeTextWidget(node, name, options = {}) { + const widgetOptions = ['multiline', 'placeholder'].reduce((obj, optKey) => { + if (optKey in options) + obj[optKey] = options[optKey]; + return obj; + }, {}); + const widget = ComfyWidgets['STRING'](node, name, ['STRING', widgetOptions], app).widget; + if (options.default) + widget.value = options.default; + if (options.label) + widget.label = options.label; + if (options.tooltip) { + if (options.multiline) + widget.inputEl.title = options.tooltip; + else + widget.tooltip = options.tooltip; + } + if (options.disabled) { + if (!options.multiline) + widget.disabled = true; + else { + widget.inputEl.readOnly = true; + widget.inputEl.style.border = 'none'; + widget.inputEl.style.opacity = 0.6; + } + } + if (options.multiline && options.domStyle) + for (const [styleKey, styleValue] of Object.entries(options.domStyle)) { + widget.inputEl.style[styleKey] = styleValue; + } + return widget; +} +export function makeButtonWidget(node, name, label, options = {}) { + options = Object.assign({ + async: true, + }, options); + const widget = node.addWidget('button', name, 0, () => { }); + widget.label = label; + if (options.tooltip) + widget.tooltip = options.tooltip; + if (options.disabled) + widget.disabled = options.disabled; + if (options.async) + makeWidgetAsync(widget); + if (options.callback) + widget.callback = options.callback; + return widget; +} +export function makeToggleWidget(node, name, options = {}) { + const widgetOptions = ['default', 'label_on', 'label_off'].reduce((obj, optKey) => { + if (optKey in options) + obj[optKey] = options[optKey]; + return obj; + }, {}); + const widget = ComfyWidgets['BOOLEAN'](node, name, ['STRING', widgetOptions], app).widget; + if (options.label) + widget.label = options.label; + if (options.tooltip) + widget.tooltip = options.tooltip; + if (options.disabled) + widget.disabled = options.disabled; + if (options.callback) + widget.callback = options.callback; + return widget; +} +export function makeComboWidget(node, name, choices, defaultSelected, onSelected, tooltip) { + const getSelected = (label) => { + if (Array.isArray(choices)) + return choices.indexOf(label); + else { + for (const [key, val] of Object.entries(choices)) { + if (val === label) + return key; + } + } + }; + const labels = Array.isArray(choices) ? choices : Object.values(choices); + const widget = node.addWidget('combo', name, choices[defaultSelected], () => { }, { values: labels }); + widget.choices = choices; + widget.selected = defaultSelected; + widget.onSelected = onSelected; + makeWidgetAsync(widget); + widget.callback = async (label) => { + widget.selected = getSelected(label); + if (widget.onSelected) + await widget.onSelected(widget.selected, label); + }; + if (tooltip) + widget.tooltip = tooltip; + const original_onNodeConfigure = node.onConfigure; + node.onConfigure = function (...args) { + widget.selected = getSelected(widget.value); + original_onNodeConfigure?.apply(this, ...args); + }; + return widget; +} +function setWidgetVisible(widget, type) { + if (type === 'hidden') { + widget.hidden = true; + widget.type = 'hidden'; + widget.computedHeight = null; + if (widget.element) { + widget.element.style.display = 'none'; + widget.element.dataset.shouldHide = true; + } + widget.computeSize = () => [0, -4]; + } + else { + delete widget.hidden; + delete widget.computeSize; + widget.type = type; + if (widget.element) { + widget.element.style.display = null; + widget.element.dataset.shouldHide = false; + } + } +} +export function makeSwitchWidget(node, name, widgetGroup1, widgetGroup2 = []) { + const serializeWidgets = (widgetGroup) => { + return widgetGroup + .filter((w) => w.name !== name) + .reduce((acc, w) => { + acc[w.name] = w.type; + return acc; + }, {}); + }; + const initialValue = { + current: true, + states: { + true: { + size: undefined, + members: serializeWidgets(widgetGroup1), + }, + false: { + size: undefined, + members: serializeWidgets(widgetGroup2), + }, + }, + }; + const widget = node.addWidget('hidden', name, initialValue, () => { }); + widget.computeSize = () => [0, -4]; + widget.switch = (value) => { + widget.value.current = value; + const states = widget.value.states; + for (const [widgetName, widgetType] of Object.entries(states[value].members)) { + const w = findWidget(node, widgetName); + if (w) { + setWidgetVisible(w, widgetType); + } + } + for (const widgetName of Object.keys(states[!value].members)) { + const w = findWidget(node, widgetName); + if (w) { + setWidgetVisible(w, 'hidden'); + } + } + for (const w of node.widgets) { + delete w.y; + delete w.last_y; + } + const height = states[value].size?.[1] || node.computeSize()[1]; + node.setSize([node.size[0], height]); + }; + widget.saveSize = () => { + widget.value.states[widget.value.current].size = [ + node.size[0], + node.size[1], + ]; + }; + const original_onResize = node.onResize; + node.onResize = function (size) { + original_onResize?.apply(this, size); + for (const w of this.widgets) { + delete w.y; + delete w.last_y; + delete w.computedHeight; + } + widget.saveSize(); + }; + const original_onConfigure = node.onConfigure; + node.onConfigure = function (...args) { + original_onConfigure?.apply(this, ...args); + widget.switch(widget.value.current); + }; + widget.guard = async (fct) => { + const contentVisible = widget.value.current; + const oldSize = [node.size[0], node.size[1]]; + const oldComputedSize = node.computeSize(); + if (contentVisible) + widget.switch(false); + await fct(); + if (contentVisible) + widget.switch(true); + const newComputedSize = node.computeSize(); + node.setSize([ + oldSize[0], + oldSize[1] + newComputedSize[1] - oldComputedSize[1], + ]); + }; + widget.switch(widget.value.current); + return widget; +} diff --git a/dist/js/widgets/misc.js b/dist/js/widgets/misc.js new file mode 100644 index 0000000..a346fbd --- /dev/null +++ b/dist/js/widgets/misc.js @@ -0,0 +1,71 @@ +import { makeButtonWidget, makeComboWidget, } from '../widgets/factories.js'; +import { makeWidgetAsync } from '../shared/utils.js'; +export function HIDDEN(node, inputName, inputData, _app) { + const initialValue = inputData[1].value; + const widget = { + type: 'HIDDEN', + name: inputName, + value: initialValue, + size: [0, -4], + computeSize: () => { + return [0, -4]; + }, + }; + node.addCustomWidget(widget); + return widget; +} +export function BTN(node, inputName, inputData) { + const label = inputData[1].label || inputName; + return makeButtonWidget(node, inputName, label, inputData[1]); +} +export function NODE_COMBO(node, name) { + const getNodeList = (_widget, thisNode) => { + const nodes = ['']; + if (thisNode) + nodes.push(...thisNode.graph._nodes + .filter((otherNode) => otherNode.id !== thisNode.id) + .map((otherNode) => { + return `#${otherNode.id}: ${otherNode.title}`; + })); + return nodes; + }; + const getSelected = (label) => { + if (!label) { + return [undefined, undefined]; + } + else { + const selected = parseInt(label.split(':')[0].substring(1)); + return [selected, node.graph._nodes_by_id[selected]]; + } + }; + const widget = node.addWidget('combo', name, '', async function (label) { + ; + [this.selected, this.selectedNode] = getSelected(label); + if (this.onSelected) + await this.onSelected(this.selected, this.selectedNode); + }, { values: getNodeList }); + makeWidgetAsync(widget); + widget.callback = async (label) => { + ; + [widget.selected, widget.selectedNode] = getSelected(label); + if (widget.onSelected) + await widget.onSelected(widget.selected, widget.selectedNode); + }; + widget.tooltip = 'select node from list'; + const original_onNodeConfigure = node.onConfigure; + node.onConfigure = function (...args) { + ; + [widget.selected, widget.selectedNode] = getSelected(widget.value); + original_onNodeConfigure?.apply(this, ...args); + }; + return widget; +} +export const ERROR_DISPLAY_CHOICES = { + browser: 'in browser console (F12)', + dialog: 'in a popup', + none: 'do not display', +}; +export function ERROR_DISPLAY(node, name = 'error_display') { + const widget = makeComboWidget(node, name, ERROR_DISPLAY_CHOICES, 'dialog', () => { }, 'how to display detected errors'); + return widget; +} diff --git a/dist/js/widgets/queue.js b/dist/js/widgets/queue.js new file mode 100644 index 0000000..d8419e7 --- /dev/null +++ b/dist/js/widgets/queue.js @@ -0,0 +1,64 @@ +import { api } from '../../../../scripts/api.js'; +function isQueueMessage(message) { + const msg = message; + return (Array.isArray(msg.index) && + msg.index.length === 1 && + typeof msg.index[0] === 'number' && + Array.isArray(msg.total) && + msg.total.length === 1 && + typeof msg.total[0] === 'number'); +} +function queueMessageToData(message) { + return { + index: message.index[0], + total: message.total[0], + }; +} +export function QUEUE_STATUS(node, inputName, _inputData, app) { + if (!app) + throw new Error('QUEUE_STATUS: app is undefined'); + const widget = node.addWidget('button', inputName, 0, () => { }); + const reset = () => { + widget.value = 0; + widget.total = undefined; + }; + reset(); + widget.label = 'Ready'; + const originalOnConfigure = node.onConfigure; + node.onConfigure = function () { + originalOnConfigure?.apply(this); + reset(); + }; + const originalOnExecuted = node.onExecuted; + node.onExecuted = function (message) { + originalOnExecuted?.apply(this, message); + if (isQueueMessage(message)) { + const data = queueMessageToData(message); + if (!widget.total) + widget.total = data.total; + if (data.index < data.total - 1) { + widget.value = data.index + 1; + widget.label = `Processing: ${widget.value} / ${widget.total}`; + app.queuePrompt(0, 1); + } + else { + widget.label = `Processing: ${widget.value + 1} / ${widget.total}`; + api.addEventListener('execution_success', () => { + widget.label = `Complete: ${widget.total} / ${widget.total}`; + reset(); + }, { once: true }); + } + } + }; + const original_api_interrupt = api.interrupt; + api.interrupt = async function (...args) { + await original_api_interrupt.apply(this, ...args); + widget.label = 'Interrupted'; + reset(); + }; + api.addEventListener('execution_error', () => { + widget.label = 'Error detected'; + reset(); + }); + return widget; +} diff --git a/eslint.config.js b/eslint.config.js new file mode 100644 index 0000000..36d8524 --- /dev/null +++ b/eslint.config.js @@ -0,0 +1,24 @@ +import globals from 'globals' +import pluginJs from '@eslint/js' +import tseslint from 'typescript-eslint' +import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended' + +/** @type {import('eslint').Linter.Config[]} */ +export default [ + pluginJs.configs.recommended, + ...tseslint.configs.recommended, + eslintPluginPrettierRecommended, + { files: ['**/*.{js,mjs,cjs,ts}'] }, + { languageOptions: { globals: globals.browser } }, + { + ignores: [ + 'coverage', + 'public', + 'dist', + '.yarn', + 'yarn.lock', + 'build/replacers.js/*.js', + 'web', + ], + }, +] diff --git a/node_list.json b/node_list.json new file mode 100644 index 0000000..a684e84 --- /dev/null +++ b/node_list.json @@ -0,0 +1,29 @@ +{ + "XY Plot: Queue (lab)": "Loop through all values of dim1, optionally combined with dim2 values, and send them to outputs", + "XY Plot: Render (lab)": "Render the generated images as grids", + "Plot Config: Grid (lab)": "Various options to customize the grid appearance", + "Plot Config: Header/Footer (lab)": "Various options to customize the appearance of the page header or footer", + "XY Plot: Split Data (lab)": "Split the queue processing data into individual values", + "List: from String (lab)": "Split a single string into elements delimited by a separator", + "List: from Multiline (lab)": "Split a multiline string, each line being a value", + "List: from File (backend) (lab)": "Read a multiline text file and send its content as a list", + "List: from Elements (lab)": "Create a list from any number of individual elements", + "List: Merge (lab)": "Merge any number of lists into one", + "List: Limit (lab)": "Limit list to a given size", + "Output Config: Load (local) (lab)": "Load a local JSON or YAML config file, and dynamically generate outputs", + "Output Config: Retrieve (backend) (lab)": "Retrieve a JSON or YAML config file from backend, and dynamically generate outputs", + "Generic Queue (lab)": "Loop through all values of input list, and send them to output", + "File Queue (lab)": "Loop through all files in folder matching the pattern(s)", + "Image Queue (lab)": "Loop through all image files in folder matching the pattern(s)", + "Input: Folder (lab)": "Simple input for a folder, optionally checking it exists", + "Input: Integer (lab)": "Simple node to provide an integer", + "Input: Float (lab)": "Simple node to provide a float", + "Input: Boolean (lab)": "Simple node to provide a boolean", + "Input: String (lab)": "Simple node to provide a string", + "Input: Multiline (lab)": "Input a multiline string, with comments optionally stripped", + "Format: String (lab)": "Format a string, with any number of inputs", + "Format: Multiline (lab)": "Format a multiline string, with any number of inputs", + "Load Image (RGBA) (lab)": "Load an image as RGBA, with 2 different available methods to generate the mask", + "Save Text File (lab)": "Save text content to a file", + "Sleep (lab)": "Delay execution for the given amount of seconds" +} \ No newline at end of file diff --git a/package.json b/package.json new file mode 100644 index 0000000..9c3b17b --- /dev/null +++ b/package.json @@ -0,0 +1,29 @@ +{ + "name": "confylab-pack", + "private": true, + "version": "0.0.0", + "type": "module", + "scripts": { + "watch": "tsc-watch -p tsconfig.json --onSuccess 'tsc-alias -p tsconfig.json -r build/replacers.js/mock.js'", + "build": "rimraf ./dist/js && tsc -p tsconfig.prod.json && tsc-alias -p tsconfig.prod.json -r build/replacers.js/mock.js", + "build:replacers": "tsc -p build/replacers.js/tsconfig.replacers.json", + "lint": "eslint .", + "format": "prettier --write ." + }, + "devDependencies": { + "@comfyorg/comfyui-frontend-types": "^1.6.8", + "@comfyorg/litegraph": "^0.8.50", + "@eslint/js": "^9.17.0", + "eslint": "^9.17.0", + "eslint-config-prettier": "^9.1.0", + "eslint-plugin-prettier": "^5.2.1", + "globals": "^15.14.0", + "prettier": "^3.4.2", + "rimraf": "^6.0.1", + "tsc-alias": "^1.8.10", + "tsc-watch": "6.2.1", + "typescript": "^5.7.2", + "typescript-eslint": "^8.18.2" + }, + "packageManager": "yarn@4.5.3+sha512.3003a14012e2987072d244c720506549c1aab73ee728208f1b2580a9fd67b92d61ba6b08fe93f6dce68fd771e3af1e59a0afa28dd242dd0940d73b95fedd4e90" +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..6c3a3c0 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,5 @@ +jsonschema +json5 +python-dotenv +pyyaml +pyaml diff --git a/src/python/__init__.py b/src/python/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/python/collection/__init__.py b/src/python/collection/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/python/collection/collect_nodes.py b/src/python/collection/collect_nodes.py new file mode 100644 index 0000000..51dbe9c --- /dev/null +++ b/src/python/collection/collect_nodes.py @@ -0,0 +1,50 @@ +import importlib +import os +from dotenv import load_dotenv # type: ignore +import json + +from .register_nodes import ALL_NODES + + +def import_all(load_env=True): + DEBUG = False + + if load_env: + load_dotenv() + DEBUG = bool(os.getenv('DEBUG')) + MAD_SCIENTIST = bool(os.getenv('MAD_SCIENTIST')) + + MODULES = ['plot', 'list', 'config', 'queue', 'input', 'utils'] + if DEBUG: + MODULES.append('debug') + if MAD_SCIENTIST: + pass + + for mod in MODULES: + importlib.import_module('...nodes.' + mod, package=__name__) + + +def make_class_mappings(): + return {cls.__name__: cls for cls in ALL_NODES.keys()} + + +def make_display_name_mappings(): + return {cls.__name__: display_name for cls, display_name in ALL_NODES.items()} + + +def make_node_list(path: str): + # node_list = { + # display_name: cls.DESCRIPTION for cls, display_name in ALL_NODES.items() + # } + node_list = {} + for cls, display_name in ALL_NODES.items(): + subcat = cls.CATEGORY.split('/')[-1].lower() + if subcat in ['debug', 'experimental']: + continue + descp = cls.DESCRIPTION.split('\n')[0] + # descp = cls.DESCRIPTION + if descp[-1] == '.': + descp = descp[:-1] + node_list[display_name] = descp + with open(path, 'w') as f: + f.write(json.dumps(node_list, indent=2)) diff --git a/src/python/collection/register_nodes.py b/src/python/collection/register_nodes.py new file mode 100644 index 0000000..ff31f81 --- /dev/null +++ b/src/python/collection/register_nodes.py @@ -0,0 +1,12 @@ +CATEGORY = 'ComfyLab' +CATSHORT = 'lab' +ALL_NODES = {} + + +def register_node(display_name: str, subcat: str = ''): + def decorator(cls): + ALL_NODES[cls] = '{} ({})'.format(display_name, CATSHORT) + cls.CATEGORY = '{}/{}'.format(CATEGORY, subcat) if subcat else CATEGORY + return cls + + return decorator diff --git a/src/python/nodes/__init__.py b/src/python/nodes/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/python/nodes/config.py b/src/python/nodes/config.py new file mode 100644 index 0000000..76b5148 --- /dev/null +++ b/src/python/nodes/config.py @@ -0,0 +1,50 @@ +from ..collection.register_nodes import register_node +from ..shared.utils import AnyReturnTypes + + +@register_node('Output Config: Load (local)', 'config') +class OutputConfigLocal: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'data': ('HIDDEN', {}), + } + } + + FUNCTION = 'run' + RETURN_TYPES = AnyReturnTypes() + + DESCRIPTION = ( + 'Load a local JSON or YAML config file, and dynamically generate outputs.' + ) + + def run(self, data): + values = [entry['value'] for entry in data.values()] + return (*values,) + + +@register_node('Output Config: Retrieve (backend)', 'config') +class OutputConfigBackend: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'data': ('HIDDEN', {}), + } + } + + FUNCTION = 'run' + RETURN_TYPES = AnyReturnTypes() + + DESCRIPTION = 'Retrieve a JSON or YAML config file from backend, and dynamically generate outputs.' + + def run(self, data): + values = [entry['value'] for entry in data.values()] + return (*values,) diff --git a/src/python/nodes/debug.py b/src/python/nodes/debug.py new file mode 100644 index 0000000..1c45732 --- /dev/null +++ b/src/python/nodes/debug.py @@ -0,0 +1,82 @@ +from ..collection.register_nodes import register_node + + +@register_node('Debug: Widget Types', 'debug') +class DebugWidgetTypes: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'a_boolean': ( + 'BOOLEAN', + {'default': True}, + ), + 'a_combo': ( + ['value1', 'value2'], + {'default': 'value2'}, + ), + 'a_string': ( + 'STRING', + {'default': 'default text', 'multiline': False}, + ), + 'a_multiline': ( + 'STRING', + {'default': 'default multline text', 'multiline': True}, + ), + 'a_int': ( + 'INT', + {'default': 65}, + ), + 'a_float': ( + 'FLOAT', + {'default': 65.76}, + ), + } + } + + FUNCTION = 'run' + RETURN_TYPES = () + RETURN_NAMES = () + DESCRIPTION = 'Debug node to test various widget types.' + + def run(self): + return () + + +@register_node('Debug: JSON / YAML parse', 'debug') +class DebugJSONYAML: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return {'required': {}} + + FUNCTION = 'run' + RETURN_TYPES = () + RETURN_NAMES = () + DESCRIPTION = 'Debug node to test JSON / YAML parse.' + + def run(self): + return () + + +@register_node('Debug: Widget Visibility', 'debug') +class DebugWidgetVisibility: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return {'required': {}} + + FUNCTION = 'run' + RETURN_TYPES = () + RETURN_NAMES = () + DESCRIPTION = 'Debug node to widget visibility.' + + def run(self): + return () diff --git a/src/python/nodes/input.py b/src/python/nodes/input.py new file mode 100644 index 0000000..7f4cd3b --- /dev/null +++ b/src/python/nodes/input.py @@ -0,0 +1,170 @@ +import os + +from ..collection.register_nodes import register_node + + +@register_node('Input: Folder', 'input') +class InputFolder: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'path': ('STRING',), + 'check_exists': ( + 'BOOLEAN', + { + 'default': True, + }, + ), + } + } + + FUNCTION = 'run' + RETURN_TYPES = ('STRING',) + RETURN_NAMES = ('path',) + OUTPUT_TOOLTIPS = ('folder path',) + DESCRIPTION = 'Simple input for a folder, optionally checking it exists' + + def run(self, path: str, check_exists: bool): + if check_exists and not os.path.isdir(path): + raise AssertionError("Folder '{0}' does not exist".format(path)) + + return (path,) + + +@register_node('Input: Integer', 'input') +class InputInteger: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return {'required': {'value': ('INT', {'default': 0})}} + + FUNCTION = 'run' + RETURN_TYPES = ('INT',) + RETURN_NAMES = ('integer',) + DESCRIPTION = 'Simple node to provide an integer.' + + def run(self, value: int): + return (value,) + + +@register_node('Input: Float', 'input') +class InputFloat: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return {'required': {'value': ('FLOAT', {'default': 0, 'step': 0.1})}} + + FUNCTION = 'run' + RETURN_TYPES = ('FLOAT',) + RETURN_NAMES = ('float',) + DESCRIPTION = 'Simple node to provide a float.' + + def run(self, value: float): + return (value,) + + +@register_node('Input: Boolean', 'input') +class InputBoolean: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return {'required': {'value': ('BOOLEAN', {'default': True})}} + + FUNCTION = 'run' + RETURN_TYPES = ('BOOLEAN',) + RETURN_NAMES = ('boolean',) + DESCRIPTION = 'Simple node to provide a boolean.' + + def run(self, value: bool): + return (value,) + + +@register_node('Input: String', 'input') +class InputString: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'string': ( + 'STRING', + {'default': '', 'multiline': False}, + ), + } + } + + FUNCTION = 'run' + RETURN_TYPES = ('STRING',) + RETURN_NAMES = ('string',) + DESCRIPTION = 'Simple node to provide a string.' + + def run(self, string: str): + return (string,) + + +@register_node('Input: Multiline', 'input') +class InputMultiline: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'load': ( + 'BTN', + { + 'label': 'Load file', + 'tooltip': 'load content from file\nor you can just paste / edit the content below', + }, + ), + 'strip_comments': ( + 'BOOLEAN', + { + 'default': True, + 'tooltip': "ignore lines starting with '#'", + }, + ), + 'multiline': ( + 'STRING', + { + 'default': '', + 'multiline': True, + 'placeholder': "multiline text\noptionally lines starting with '#' can be ignored", + }, + ), + } + } + + FUNCTION = 'run' + RETURN_TYPES = ('STRING',) + RETURN_NAMES = ('multiline',) + OUTPUT_TOOLTIPS = ('multiline text, with comments optionally stripped',) + DESCRIPTION = 'Input a multiline string, with comments optionally stripped.' + + def run( + self, + load, + strip_comments: bool, + multiline: str, + ): + lines = multiline.split('\n') + output = [] + for line in lines: + line = line.strip() + if line != '' and (not line.startswith('#') or not strip_comments): + output.append(line) + + return ('\n'.join(output),) diff --git a/src/python/nodes/list.py b/src/python/nodes/list.py new file mode 100644 index 0000000..870d25c --- /dev/null +++ b/src/python/nodes/list.py @@ -0,0 +1,385 @@ +import hashlib + +from ..collection.register_nodes import register_node + + +def convert_value(value: str, output_type: str): + value = value.lower() + if value == 'none': + return None + match output_type: + case 'float': + return float(value) + case 'integer': + return int(value) + case 'boolean': + if value in ('true', 'y', 'yes', 't', 'on', '1'): + return True + elif value in ('false', 'n', 'no', 'f', 'off', '0'): + return False + else: + raise ValueError('invalid boolean value {}'.format(value)) + case _: + return value + + +# common tooltips +TOOLTIP_STRIP_COMMENTS = "ignore lines starting with '#'" +TOOLTIP_CONVERT = 'convert each value to int, float or boolean\nfor booleans, values like true/false, yes/no, on/off, 0/1... are accepted.' +TOOLTIP_OUTPUT_SEPARATED = str( + 'list of values, splitted using the separator, optionally converted' +) +TOOLTIP_OUTPUT_MULTILINE = 'list of values (one per line, optionally converted)' +TOOLTIP_OUTPUT_COUNT = 'number of values' + + +@register_node('List: from String', 'list') +class ListFromString: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'string': ( + 'STRING', + { + 'default': '', + 'multiline': False, + 'placeholder': 'single string', + 'tooltip': 'single string to be splitted by separator', + }, + ), + 'separator': ( + 'STRING', + { + 'default': ',', + 'multiline': False, + 'tooltip': 'element seperator (spaces surrounding values will be trimmed)', + }, + ), + 'convert': ( + ['disabled', 'integer', 'float', 'boolean'], + { + 'default': 'disabled', + 'tooltip': TOOLTIP_CONVERT, + }, + ), + } + } + + FUNCTION = 'run' + RETURN_TYPES = ('LIST', 'INT') + RETURN_NAMES = ('list', 'count') + OUTPUT_TOOLTIPS = ( + TOOLTIP_OUTPUT_SEPARATED, + TOOLTIP_OUTPUT_COUNT, + ) + DESCRIPTION = 'Split a single string into elements delimited by a separator\nBy default the list elements are strings, but they can be converted.' + + def run( + self, + string: str, + separator: str, + convert: str, + ): + lines = string.split(separator) + output = [] + for line in lines: + line = line.strip() + if convert != 'disabled': + line = convert_value(line, convert) + output.append(line) + return (output, len(output)) + + +@register_node('List: from Multiline', 'list') +class ListFromMultiline: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'load': ( + 'BTN', + { + 'label': 'Load file', + 'tooltip': 'load content from file\nor you can just paste / edit the content below', + }, + ), + 'strip_comments': ( + 'BOOLEAN', + { + 'default': True, + 'tooltip': TOOLTIP_STRIP_COMMENTS, + }, + ), + 'convert': ( + ['disabled', 'integer', 'float', 'boolean'], + { + 'default': 'disabled', + 'tooltip': TOOLTIP_CONVERT, + }, + ), + 'multiline': ( + 'STRING', + { + 'default': '', + 'multiline': True, + 'placeholder': "multiline text\noptionally lines starting with '#' can be ignored", + }, + ), + } + } + + FUNCTION = 'run' + RETURN_TYPES = ('LIST', 'INT') + RETURN_NAMES = ('list', 'count') + OUTPUT_TOOLTIPS = ( + TOOLTIP_OUTPUT_MULTILINE, + TOOLTIP_OUTPUT_COUNT, + ) + DESCRIPTION = "Split a multiline string, each line being a value\nBy default the list elemenrs are strings, but they can be converted\nOptionally, lines starting with '#' can be ignored." + + def run( + self, + load, + strip_comments: bool, + convert: str, + multiline: str, + ): + lines = multiline.split('\n') + output = [] + for line in lines: + line = line.strip() + if line != '' and (not line.startswith('#') or not strip_comments): + if convert != 'disabled': + line = convert_value(line, convert) + output.append(line) + + return (output, len(output)) + + +# @register_node('Input Multiline To Batch', 'list') +# class BatchFromMultiline: +# def __init__(self): +# pass + +# @classmethod +# def INPUT_TYPES(s): +# return { +# 'required': { +# 'separator': ( +# 'STRING', +# {'default': ',', 'multiline': False}, +# ), +# 'index': ( +# 'INT', +# { +# 'min': 0, +# 'default': 0, +# }, +# ), +# 'multiline': ( +# 'STRING', +# {'default': '', 'multiline': True}, +# ), +# } +# } + +# RETURN_TYPES = ('LIST', 'INT', 'INT') +# RETURN_NAMES = ('list', 'batch index', 'batch total') + +# FUNCTION = 'run' + +# def run( +# self, +# separator: str, +# index: int, +# multiline: str, +# ): +# lines = multiline.split('\n') +# output = [] +# for line in lines: +# tokens = line.split(separator) +# trimmed = [] +# for token in tokens: +# trimmed.append(token.strip()) +# output.append(trimmed) + +# return (output[index], index, len(output)) + + +@register_node('List: from File (backend)', 'list') +class ListFromFile: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'file_path': ( + 'STRING', + { + 'default': '', + 'placeholder': 'full path to file', + 'tooltip': 'full path to file (backend)', + }, + ), + 'strip_comments': ( + 'BOOLEAN', + {'default': True, 'tooltip': TOOLTIP_STRIP_COMMENTS}, + ), + 'convert': ( + ['disabled', 'integer', 'float', 'boolean'], + { + 'default': 'disabled', + 'tooltip': TOOLTIP_CONVERT, + }, + ), + } + } + + FUNCTION = 'run' + RETURN_TYPES = ('LIST', 'INT') + RETURN_NAMES = ('list', 'count') + OUTPUT_TOOLTIPS = ( + TOOLTIP_OUTPUT_MULTILINE, + TOOLTIP_OUTPUT_COUNT, + ) + DESCRIPTION = 'Read a multiline text file and send its content as a list\nBy default the list elements are strings, but they can be converted.' + + # force reloading in case the file has been changed externally + # we cannot return float('NaN') as usually, otherwise nodes like ListMerge may not work properly + # so we calculate the MD5 checksum, and add it to the returned dict, which is used to determine is the node has changed + @classmethod + def IS_CHANGED(cls, **kwargs): + current = kwargs + # try to open the open and calculate the checksum + try: + with open(current['file_path'], 'rb') as f: + data = f.read() + current['md5'] = hashlib.md5(data).hexdigest() + except: + pass + return current + + def run( + self, + file_path: str, + strip_comments: bool, + convert: str, + ): + with open( + file_path, 'rt' + ) as f: # that's the standard mode, but hey let's be rigorous + lines = f.readlines() + output = [] + for line in lines: + line = line.strip() + if line != '' and (not line.startswith('#') or not strip_comments): + if convert != 'disabled': + line = convert_value(line, convert) + output.append(line) + + return (output, len(output)) + + +@register_node('List: from Elements', 'list') +class ListFromElements: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return {'required': {}} + + FUNCTION = 'run' + RETURN_TYPES = ('LIST', 'INT') + RETURN_NAMES = ('list', 'count') + OUTPUT_TOOLTIPS = ( + 'list', + TOOLTIP_OUTPUT_COUNT, + ) + DESCRIPTION = 'Create a list from any number of individual elements.' + + def run(self, **kw): + output = [] + for elt in kw.values(): + output.append(elt) + + return (output, len(output)) + + +@register_node('List: Merge', 'list') +class ListMerge: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return {'required': {}} + + FUNCTION = 'run' + RETURN_TYPES = ('LIST', 'INT') + RETURN_NAMES = ('list', 'count') + OUTPUT_TOOLTIPS = ( + 'merged list', + TOOLTIP_OUTPUT_COUNT, + ) + DESCRIPTION = 'Merge any number of lists into one.' + + def run(self, **kw): + output = [] + for l in kw.values(): + output += l + + return (output, len(output)) + + +@register_node('List: Limit', 'list') +class ListLimit: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'list': ('LIST', {'tooltip': 'list to extract from'}), + 'nb_elements': ( + 'INT', + {'default': 1, 'min': 1, 'tooltip': 'number of elements'}, + ), + 'method': ( + ['first', 'last'], + { + 'default': 'first', + 'tooltip': 'how to extract', + }, + ), + } + } + + FUNCTION = 'run' + RETURN_TYPES = ('LIST', 'INT') + RETURN_NAMES = ('list', 'count') + OUTPUT_TOOLTIPS = ( + 'limited list', + TOOLTIP_OUTPUT_COUNT, + ) + DESCRIPTION = 'Limit list to a given size.' + + def run(self, list, nb_elements: int, method: str): + output = [] + match method: + case 'first': + output = list[:nb_elements] + case 'last': + output = list[-nb_elements:] + + return (output, len(output)) diff --git a/src/python/nodes/plot.py b/src/python/nodes/plot.py new file mode 100644 index 0000000..3217d37 --- /dev/null +++ b/src/python/nodes/plot.py @@ -0,0 +1,506 @@ +from comfy_execution.graph import ExecutionBlocker # type: ignore +import torch # type: ignore +from math import ceil + +from ..collection.register_nodes import register_node +from ..shared.utils import ANY_TYPE +from ..shared.plot_data import ( + DimData, + XYPlotQueueData, + PlotConfigHFData, + PlotConfigGridData, + PlotVars, +) +from ..shared.pager import Pager + +# common tooltips +TOOLTIP_XY_PLOT_DATA = ( + 'data sent by the queue, to indicate the cuttent state of processing' +) +TOOLTIP_COLOR = ( + "can be either a color name ('red'), or the RGB hex notation ('#b9b9b9', '#aaa')" +) +TOOLTIP_FONT = "font: either one of 'Roboto-Regular.ttf' / 'Roboto-Bold.ttf' / 'Roboto-Italic.ttf' / 'Roboto-BoldItalic.ttf',\nor the full path to a locally-installed TTF font" +TOOLTIP_FONT_SIZE = 'font size' +TOOLTIP_FONT_COLOR = 'font color, ' + TOOLTIP_COLOR +TOOLTIP_HF_PLACEHOLDERS = ( + 'the following placeholders are accepted: {current_page}, {total_pages}' +) +TOOLTIP_PLOT_CONFIG_GRID = 'plot configuration for the grid' + + +@register_node('XY Plot: Queue', 'plot') +class XYPlotQueue: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'dim1': ( + 'LIST', + { + 'tooltip': 'list of values, processed by queue as the 1st dimension\ntip: associate slow operation, like loading checkpoint, to dim1, to ensure better performance' + }, + ), + }, + 'optional': { + 'dim2': ( + 'LIST', + { + 'tooltip': 'optional: list of values, processed by queue as the 2nd dimension' + }, + ), + 'index': ('QUEUE_STATUS', {'tooltip': 'current queue status'}), + 'max_dim1_per_page': ( + 'INT', + { + 'default': 0, + 'min': 0, + 'tooltip': 'optional: if > 0, max number of dim1 values per page', + }, + ), + 'max_dim2_per_page': ( + 'INT', + { + 'default': 0, + 'min': 0, + 'tooltip': 'optional: if > 0, max number of dim2 values per page', + }, + ), + }, + } + + FUNCTION = 'run' + RETURN_TYPES = (ANY_TYPE, ANY_TYPE, 'XY_PLOT_DATA') + RETURN_NAMES = ('dim1_value', 'dim2_value', 'xy_plot_data') + OUTPUT_TOOLTIPS = ( + 'dim1 value (not typed)', + 'dim2 value (not typed)', + TOOLTIP_XY_PLOT_DATA, + ) + DESCRIPTION = 'Loop through all values of dim1, optionally combined with dim2 values, and send them to outputs.\nIMPORTANT: for a given dim1 value, all dim2 values are first iterated, before going to the next dim1 value.\nSo it is advised to associate slow operations (e.g. loading checkpoints) to dim1, to ensure better performance.' + + def run( + self, + dim1: list[str], + max_dim1_per_page: int, + max_dim2_per_page: int, + index: int, + dim2: list[str] = [''], + ): + if len(dim2) == 0: + dim2 = [''] + + # to simplify code below + size = (len(dim1), len(dim2)) + dim1_limited = max_dim1_per_page > 0 and max_dim1_per_page < size[0] + dim2_limited = max_dim2_per_page > 0 and max_dim2_per_page < size[1] + + # calculate total + total = size[0] * size[1] + + # check if we have finished + complete = index == total - 1 + + # max page dimensions, but not necessarily the current page ones: the last one may be smaller + max_page_dims = ( + max_dim1_per_page if dim1_limited else size[0], + max_dim2_per_page if dim2_limited else size[1], + ) + + # page index and total nb of pages + total_pages = ( + ceil(size[0] / max_page_dims[0]), + ceil(size[1] / max_page_dims[1]), + ) + # compute the index and dimension of the current page for dim1 first + current_page_index_dim1 = int(index / (size[1] * max_page_dims[0])) + current_page_dims_dim1 = min( + max_page_dims[0], size[0] - current_page_index_dim1 * max_page_dims[0] + ) + + # compute the index and dimension of the current page for dim2 + current_page = ( + current_page_index_dim1, + int( + (index - current_page_index_dim1 * size[1] * max_page_dims[0]) + / (current_page_dims_dim1 * max_page_dims[1]) + ) + % size[1], + ) + current_page_dims = ( + current_page_dims_dim1, + min(max_page_dims[1], size[1] - current_page[1] * max_page_dims[1]), + ) + + # sequential index and dim1/dim2 indexes in current page + index_in_page_seq = ( + index + - current_page[0] * size[1] * max_page_dims[0] + - current_page[1] * current_page_dims[0] * max_page_dims[1] + ) + index_in_page = ( + int(index_in_page_seq / current_page_dims[1]), + int(index_in_page_seq % current_page_dims[1]), + ) + + # get value from each list, given the paged index + values = ( + dim1[ + int(index_in_page_seq / current_page_dims[1]) + + current_page[0] * max_page_dims[0] + ], + dim2[ + int(index_in_page_seq % current_page_dims[1]) + + current_page[1] * max_page_dims[1] + ], + ) + + # build data sent to XYPlotRender + xy_plot_data = XYPlotQueueData( + index_in_page_seq, + current_page[0] * total_pages[1] + current_page[1], + total_pages[0] * total_pages[1], + complete, + DimData(index_in_page[0], current_page_dims[0], values[0]), + DimData(index_in_page[1], current_page_dims[1], values[1]), + ) + + return { + 'result': (values[0], values[1], xy_plot_data), + 'ui': {'index': [index], 'total': [total]}, + } + + +@register_node('XY Plot: Render', 'plot') +class XYPlotRender: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'xy_plot_data': ('XY_PLOT_DATA', {'tooltip': TOOLTIP_XY_PLOT_DATA}), + 'image': ('IMAGE',), + 'dim1_header_format': ( + 'STRING', + { + 'default': 'dim1: {dim1}', + 'tooltip': "temoplate text to be displayed as dim1 header.\nthe '{dim1'} placeholder will be replaced by the current value.\nUse '\\n' for multiline text.", + }, + ), + 'dim2_header_format': ( + 'STRING', + { + 'default': 'dim2: {dim2}', + 'tooltip': "temoplate text to be displayed as dim2 header.\nthe '{dim2'} placeholder will be replaced by the current value.\nUse '\\n' for multiline text.", + }, + ), + 'direction': ( + 'BOOLEAN', + { + 'default': True, + 'label_on': 'dim1 as rows', + 'label_off': 'dim1 as cols', + 'tooltip': 'display dim1 values as rows or columns', + }, + ), + }, + 'optional': { + 'plot_config_grid': ( + 'PLOT_CONFIG_GRID', + {'tooltip': 'optional: ' + TOOLTIP_PLOT_CONFIG_GRID}, + ), + 'plot_config_header': ( + 'PLOT_CONFIG_HF', + {'tooltip': 'optional: plot configuration for the page header'}, + ), + 'plot_config_footer': ( + 'PLOT_CONFIG_HF', + {'tooltip': 'optional: plot configuration for the page footer'}, + ), + }, + } + + FUNCTION = 'run' + RETURN_TYPES = ('IMAGE', 'IMAGE') + RETURN_NAMES = ('grid', 'image') + OUTPUT_TOOLTIPS = ( + 'grid page', + 'individual image, as received in input', + ) + DESCRIPTION = 'Render the generated images as grids.\nOptional configuration is available to customize the look of the grid, and page header / footer.' + + # Pager object, to hold each individual images and build the grid + pager = None + + def run( + self, + xy_plot_data: XYPlotQueueData, + image: torch.Tensor, + dim1_header_format: str, + dim2_header_format: str, + direction: bool, + plot_config_grid=PlotConfigGridData(), + plot_config_header=None, + plot_config_footer=None, + ): + if xy_plot_data.index == 0: + self.pager = Pager( + xy_plot_data, (dim1_header_format, dim2_header_format), direction + ) + + # add image to pager + self.pager.add(xy_plot_data, image) + + # check if page is complete + if not self.pager.complete: + # block downstream nodes for grid output, just send the individual image + return {'result': (ExecutionBlocker(None), image)} + else: + grid = self.pager.make_grid( + PlotVars(xy_plot_data.current_page + 1, xy_plot_data.total_pages), + plot_config_grid, + plot_config_header, + plot_config_footer, + ) + # complete, send grid + individual image + return ( + grid, + image, + ) + + +@register_node('Plot Config: Grid', 'plot') +class PlotConfigGrid: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'gap': ( + 'INT', + {'default': 20, 'min': 0, 'tooltip': 'gap between grid cells'}, + ), + 'background_color': ( + 'STRING', + { + 'default': '#b9b9b9', + 'tooltip': 'background color, ' + + TOOLTIP_COLOR + + "\nuse the special value 'transparent' to generate a RGBA image", + }, + ), + 'font': ( + 'STRING', + { + 'default': 'Roboto-Regular.ttf', + 'tooltip': TOOLTIP_FONT, + }, + ), + 'font_size': ( + 'INT', + {'default': 50, 'min': 1, 'tooltip': TOOLTIP_FONT_SIZE}, + ), + 'font_color': ( + 'STRING', + {'default': '#444', 'tooltip': TOOLTIP_FONT_COLOR}, + ), + 'pad_col_headers': ( + 'INT', + { + 'default': 30, + 'min': 0, + 'tooltip': 'vertical padding to apply to column headers', + }, + ), + 'pad_row_headers': ( + 'INT', + { + 'default': 50, + 'min': 0, + 'tooltip': 'horizontal padding to apply to row headers', + }, + ), + 'wrap_col_headers': ( + 'INT', + { + 'default': 0, + 'min': 0, + 'tooltip': 'if > 0, max number of characters in column headers before wrapping', + }, + ), + 'wrap_row_headers': ( + 'INT', + { + 'default': 0, + 'min': 0, + 'tooltip': 'if > 0, max number of characters in row headers before wrapping', + }, + ), + }, + } + + FUNCTION = 'run' + RETURN_TYPES = ('PLOT_CONFIG_GRID',) + RETURN_NAMES = ('plot_config_grid',) + OUTPUT_TOOLTIPS = (TOOLTIP_PLOT_CONFIG_GRID,) + DESCRIPTION = 'Various options to customize the grid appearance.' + + def run( + self, + gap: int, + background_color: str, + font: str, + font_size: int, + font_color: str, + pad_col_headers: int, + pad_row_headers: int, + wrap_col_headers: int, + wrap_row_headers: int, + ): + plot_config_grid = PlotConfigGridData( + gap=gap, + background_color=background_color, + font=font, + font_size=font_size, + font_color=font_color, + pad_col_headers=pad_col_headers, + pad_row_headers=pad_row_headers, + wrap_col_headers=wrap_col_headers, + wrap_row_headers=wrap_row_headers, + ) + return (plot_config_grid,) + + +@register_node('Plot Config: Header/Footer', 'plot') +class PlotConfigHF: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'text_left': ( + 'STRING', + { + 'default': '', + 'tooltip': 'text to be displayed on the left of the page header or footer\n' + + TOOLTIP_HF_PLACEHOLDERS, + }, + ), + 'text_center': ( + 'STRING', + { + 'default': '', + 'tooltip': 'text to be displayed at the center of the page header or footer\n' + + TOOLTIP_HF_PLACEHOLDERS, + }, + ), + 'text_right': ( + 'STRING', + { + 'default': '', + 'tooltip': 'text to be displayed on the right of the page header or footer\n' + + TOOLTIP_HF_PLACEHOLDERS, + }, + ), + 'background_color': ( + 'STRING', + { + 'default': 'transparent', + 'tooltip': 'background color for the page header or footer, ' + + TOOLTIP_COLOR + + "\nuse the special value 'transparent' to keep the grid background", + }, + ), + 'font': ( + 'STRING', + {'default': 'Roboto-Bold.ttf', 'tooltip': TOOLTIP_FONT}, + ), + 'font_size': ( + 'INT', + {'default': 60, 'min': 1, 'tooltip': TOOLTIP_FONT_SIZE}, + ), + 'font_color': ( + 'STRING', + {'default': '#222', 'tooltip': TOOLTIP_FONT_COLOR}, + ), + 'padding': ( + 'INT', + { + 'default': 30, + 'min': 0, + 'tooltip': 'padding inside the page header or footer', + }, + ), + }, + } + + FUNCTION = 'run' + RETURN_TYPES = ('PLOT_CONFIG_HF',) + RETURN_NAMES = ('plot_config_hf',) + OUTPUT_TOOLTIPS = ('plot configuration for either the page header or footer',) + DESCRIPTION = ( + 'Various options to customize the appearance of the page header or footer.' + ) + + def run( + self, + text_left: str, + text_center: str, + text_right: str, + background_color: str, + font: str, + font_size: int, + font_color: str, + padding: int, + ): + plot_config_hf = PlotConfigHFData( + text_left=text_left, + text_center=text_center, + text_right=text_right, + font=font, + background_color=background_color, + font_size=font_size, + font_color=font_color, + padding=padding, + ) + return (plot_config_hf,) + + +@register_node('XY Plot: Split Data', 'plot') +class XYPlotDataSplit: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'xy_plot_data': ('XY_PLOT_DATA', {'tooltip': TOOLTIP_XY_PLOT_DATA}), + }, + } + + FUNCTION = 'run' + RETURN_TYPES = ('INT', 'INT', 'BOOLEAN') + RETURN_NAMES = ('current_page', 'total_pages', 'complete') + OUTPUT_TOOLTIPS = ( + 'current page', + 'total number of pages', + 'is processing complete? (BOOLEAN)', + ) + DESCRIPTION = 'Split the queue processing data into individual values.\nUseful to customize the filename during saving, for example.' + + def run(self, xy_plot_data: XYPlotQueueData): + return ( + xy_plot_data.current_page + 1, + xy_plot_data.total_pages, + xy_plot_data.complete, + ) diff --git a/src/python/nodes/queue.py b/src/python/nodes/queue.py new file mode 100644 index 0000000..66facc4 --- /dev/null +++ b/src/python/nodes/queue.py @@ -0,0 +1,211 @@ +from typing import Any +from pathlib import Path +from PIL import Image + + +from ..collection.register_nodes import register_node +from ..shared.utils import ANY_TYPE, pillow_to_tensor + + +@register_node('Generic Queue', 'queue') +class GenericQueue: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'input_list': ( + 'LIST', + {'tooltip': 'list of values, processed by queue'}, + ), + }, + 'optional': { + 'index': ('QUEUE_STATUS', {'tooltip': 'current queue status'}), + }, + } + + FUNCTION = 'run' + RETURN_TYPES = (ANY_TYPE, 'INT', 'INT') + RETURN_NAMES = ('value', 'index', 'total') + OUTPUT_TOOLTIPS = ('current value (not typed)', 'current index', 'total elements') + DESCRIPTION = 'Loop through all values of input list, and send them to output.' + + def run(self, input_list: list[Any], index: int): + total = len(input_list) + if total == 0: + raise Exception('Empty input list') + return { + 'result': (input_list[index], index + 1, total), + 'ui': {'index': [index], 'total': [total]}, + } + + +@register_node('File Queue', 'queue') +class FileQueue: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'folder': ( + 'STRING', + {'tooltip': 'folder to scan'}, + ), + 'pattern': ( + 'STRING', + { + 'default': '*', + 'tooltip': "file pattern(s) to match, e.g. '*.txt' or 'prefix*'.\nmultiple patterns can be defined, separated by a comma", + }, + ), + 'recursive': ( + 'BOOLEAN', + {'default': True, 'tooltip': 'scan recursively?'}, + ), + 'with_extension': ( + 'BOOLEAN', + {'default': True, 'tooltip': 'keep or remove file extension'}, + ), + }, + 'optional': { + 'index': ('QUEUE_STATUS', {'tooltip': 'current queue status'}), + }, + } + + FUNCTION = 'run' + RETURN_TYPES = ('STRING', 'STRING', 'STRING', 'INT', 'INT') + RETURN_NAMES = ('filename', 'full_path', 'relative_path', 'index', 'total') + OUTPUT_TOOLTIPS = ( + 'filename', + 'full path', + 'relative path', + 'current index', + 'total files', + ) + DESCRIPTION = 'Loop through all files in folder matching the pattern(s).' + + # stored scanned files + root = '' + files = [] + total = -1 + + def scan_folder( + self, folder: str, pattern: str, recursive: bool + ) -> tuple[Path, list[Path], int]: + self.root = Path(folder) + self.files = [] + self.total = -1 + + if not self.root.exists(): + raise Exception("Path '{}' does not exist".format(self.root)) + if not self.root.is_dir(): + raise Exception("'{}' is not a directory".format(self.root)) + + patterns = pattern.split(',') + self.files = [] + for p in patterns: + it = self.root.rglob(p.strip()) if recursive else self.root.glob(p.strip()) + self.files += [file for file in it if file.is_file()] + # remove duplicates + self.files = list(set(self.files)) + # list files in current folder first + self.files.sort(key=lambda f: [f.parent, f.name]) + self.total = len(self.files) + if len(self.files) == 0: + raise Exception('No file found') + + def run( + self, + folder: str, + pattern: str, + recursive: bool, + with_extension: bool, + index: int, + ): + # only scan files at the beginning + if index == 0: + self.scan_folder(folder, pattern, recursive) + + file = self.files[index] + return { + 'result': ( + str(file.name) if with_extension else file.stem, + str(file.resolve()), + str(file.relative_to(self.root)), + index + 1, + self.total, + ), + 'ui': {'index': [index], 'total': [self.total]}, + } + + +@register_node('Image Queue', 'queue') +class ImageQueue(FileQueue): + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'folder': ( + 'STRING', + {'tooltip': 'folder to scan'}, + ), + 'pattern': ( + 'STRING', + { + 'default': '*.png, *.jpg', + 'tooltip': "file pattern(s) to match, e.g. '*.jpg' or 'prefix*'.\nmultiple patterns can be defined, separated by a comma", + }, + ), + 'recursive': ( + 'BOOLEAN', + {'default': True, 'tooltip': 'scan recursively?'}, + ), + 'with_extension': ( + 'BOOLEAN', + {'default': True, 'tooltip': 'keep or remove file extension'}, + ), + }, + 'optional': { + 'index': ('QUEUE_STATUS', {'tooltip': 'current queue status'}), + }, + } + + RETURN_TYPES = ('IMAGE', 'STRING', 'STRING', 'STRING', 'INT', 'INT') + RETURN_NAMES = ('image', 'filename', 'full_path', 'relative_path', 'index', 'total') + OUTPUT_TOOLTIPS = ( + 'image', + 'filename', + 'full path', + 'relative path', + 'current index', + 'total files', + ) + DESCRIPTION = 'Loop through all image files in folder matching the pattern(s).' + + def run( + self, + folder: str, + pattern: str, + recursive: bool, + with_extension: bool, + index: int, + ): + parent_run = super().run(folder, pattern, recursive, with_extension, index) + + file = parent_run['result'][1] + img = Image.open(file) + + return { + 'result': ( + pillow_to_tensor(img), + *parent_run['result'], + ), + 'ui': {**parent_run['ui']}, + } diff --git a/src/python/nodes/utils.py b/src/python/nodes/utils.py new file mode 100644 index 0000000..9ac6e78 --- /dev/null +++ b/src/python/nodes/utils.py @@ -0,0 +1,267 @@ +from typing import Any +import time +import os +from PIL import Image +import numpy as np +import torch # type: ignore + +import folder_paths # type: ignore + +from ..collection.register_nodes import register_node +from ..shared.utils import ANY_TYPE, pillow_to_tensor + + +@register_node('Format: String', 'utils') +class FormatString: + """ + Format a string using any number of inputs + """ + + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'format': ( + 'STRING', + { + 'default': 'first arg by name: {arg0}, second by index: {1}', + 'multiline': False, + 'tooltip': "placeholders can be either '{arg0}', '{arg1}, ... or '{0}', '{1}', ...", + }, + ), + } + } + + @classmethod + def VALIDATE_INPUTS(s, input_types): + for t in input_types.values(): + if t not in ['STRING', 'INT', 'FLOAT', 'BOOLEAN']: + return False + return True + + FUNCTION = 'run' + RETURN_TYPES = ('STRING',) + RETURN_NAMES = ('formatted',) + DESCRIPTION = "Format a string, with any number of inputs.\nPlaceholders can be either '{arg0}', '{arg1}, ... or '{0}', '{1}', ...\nInputs can be strings, integers, floats, booleans.\nSearch for 'python format' for all configuration options, there are many!" + + def run(self, format: str, **kw): + # handle both index and name references + output = format.format(*kw.values(), **kw) + + return (output,) + + +@register_node('Format: Multiline', 'utils') +class FormatMultiline: + """ + Format a multiline string using any number of inputs + """ + + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'format': ( + 'STRING', + { + 'default': 'first arg by name: {arg0}\nsecond by index: {1}', + 'multiline': True, + 'tooltip': "placeholders can be either '{arg0}', '{arg1}, ... or '{0}', '{1}', ...", + }, + ), + } + } + + @classmethod + def VALIDATE_INPUTS(s, input_types): + for t in input_types.values(): + if t not in ['STRING', 'INT', 'FLOAT', 'BOOLEAN']: + return False + return True + + FUNCTION = 'run' + RETURN_TYPES = ('STRING',) + RETURN_NAMES = ('formatted',) + DESCRIPTION = "Format a multiline string, with any number of inputs.\nPlaceholders can be either '{arg0}', '{arg1}, ... or '{0}', '{1}', ...\nInputs can be strings, integers, floats, booleans." + + def run(self, format: str, **kw): + # handle both index and name references + output = format.format(*kw.values(), **kw) + + return (output,) + + +@register_node('Load Image (RGBA)', 'utils') +class LoadImageRGBA: + """Load an image as RGBA. + + - filename_ext: whether to return the filename with or without the extension. + - mask_precision: either 'standard' or 'tensor'. Defines the way the mask is created. + - 'standard' is like standard LoadImage + - 'tensor' is less conservative + """ + + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + input_dir = folder_paths.get_input_directory() + files = [ + f + for f in os.listdir(input_dir) + if os.path.isfile(os.path.join(input_dir, f)) + ] + return { + 'required': { + 'image': (sorted(files), {'image_upload': True}), + 'with_extension': ( + 'BOOLEAN', + { + 'default': False, + 'label_on': 'filename with ext', + 'label_off': 'filename without ext', + 'tooltip': 'output the filename with or without extension', + }, + ), + 'mask_precision': ( + ['tensor', 'standard'], + { + 'default': 'tensor', + 'tooltip': "'standard' is like standard LoadImage, 'tensor' is less conservative", + }, + ), + } + } + + FUNCTION = 'run' + RETURN_TYPES = ('IMAGE', 'MASK', 'STRING') + RETURN_NAMES = ('image', 'mask', 'filename') + DESCRIPTION = 'Load an image as RGBA, with 2 different available methods to generate the mask.' + + def run(self, image, with_extension, mask_precision): + img_path = folder_paths.get_annotated_filepath(image) + img_pil = Image.open(img_path) + + # filename output + filename = os.path.basename(img_path) + if with_extension == False: + filename = os.path.splitext(filename)[0] + + output_images = [] + output_masks = [] + + # convert image to tensor + output_image = pillow_to_tensor(img_pil) + + # create mask + if mask_precision == 'standard': + if 'A' in img_pil.getbands(): + output_mask = ( + np.array(img_pil.getchannel('A')).astype(np.float32) / 255.0 + ) + output_mask = 1.0 - torch.from_numpy(output_mask) + else: + output_mask = torch.zeros( + (img_pil.size[1], img_pil.size[0]), + dtype=torch.float32, + device='cpu', + ) + else: + # another way to create mask, but seems less precise (which may be good) + # https://stackoverflow.com/questions/70786249/pytorch-numpy-create-binary-mask-from-rgb-image + image_sum = output_image.sum(axis=3) + output_mask = torch.where(image_sum > 0, 1.0, 0.0) + output_mask = 1.0 - output_mask + + output_images.append(output_image) + output_masks.append(output_mask) + + return (output_image, output_mask, filename) + + +@register_node('Save Text File', 'utils') +class SaveTextFile: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'text': ('STRING',), + 'folder': ('STRING',), + 'basename': ( + 'STRING', + { + 'tooltip': 'filename without extension, or with extension is no extension is set below' + }, + ), + 'extension': ( + 'STRING', + { + 'default': 'txt', + 'tooltip': 'if no extension is set here, basename should include one', + }, + ), + 'overwrite': ('BOOLEAN', {'default': True}), + } + } + + FUNCTION = 'run' + RETURN_TYPES = () + OUTPUT_NODE = True + DESCRIPTION = 'Save text content to a file.\nIf no extension is set, basename is the filename.' + + def run( + self, text: str, folder: str, basename: str, extension: str, overwrite: bool + ): + if extension and not extension.startswith('.'): + extension = '.' + extension + full_path = os.path.join(folder, basename + extension) + + if not os.path.exists(full_path) or overwrite: + with open(full_path, 'w') as f: + f.write(text) + + return () + + +@register_node('Sleep', 'utils') +class Sleep: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': { + 'input': (ANY_TYPE, {}), + }, + 'optional': { + 'seconds': ( + 'FLOAT', + { + 'default': 0.5, + 'min': 0, + 'step': 0.1, + 'tooltip': 'nb of seconds to wait', + }, + ), + }, + } + + FUNCTION = 'run' + RETURN_TYPES = (ANY_TYPE,) + RETURN_NAMES = ('value',) + DESCRIPTION = 'Delay execution for the given amount of seconds.' + + def run(self, input: Any, seconds: float): + time.sleep(seconds) + return (input,) diff --git a/src/python/shared/__init__.py b/src/python/shared/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/python/shared/api.py b/src/python/shared/api.py new file mode 100644 index 0000000..c3dfb01 --- /dev/null +++ b/src/python/shared/api.py @@ -0,0 +1,158 @@ +import json +import json5 # type: ignore +import yaml +import pyaml # type: ignore +import mimetypes +from pathlib import Path +from aiohttp.web import Request, json_response # type: ignore +from server import PromptServer # type: ignore + +from ..shared.json_validation import validate, SchemaError, InvalidStructureError + +routes = PromptServer.instance.routes + + +def send_success(**kwargs): + return json_response({**kwargs}, status=200) + + +def send_error(status: int, reason: str = None, **kwargs): + return json_response({**kwargs}, status=status, reason=reason) + + +class ParseError(Exception): + pass + + +# Parse content, either as JSON or YAML +def parse(raw: str): + try: + parsed = json5.loads(raw) + prettified = json.dumps(parsed, sort_keys=False, indent=2) + return ('json', parsed, prettified) + except Exception: + pass + try: + parsed = yaml.safe_load(raw) + prettified = pyaml.dump( + parsed, + sort_keys=False, + ) + return ('yaml', parsed, prettified) + except Exception: + pass + raise ParseError('parse error') + + +# Convert data, either to JSON or YAML +def convert(data, format: str) -> str: + if format == 'json': + return json.dumps(data, sort_keys=False, indent=2) + elif format == 'yaml': + return pyaml.dump( + data, + sort_keys=False, + ) + + +@routes.post('/comfylab/load_file') +async def load_file(request: Request): + try: + body = await request.json() + if not 'path' in body.keys(): + return send_error( + status=500, + reason='Path missing in request', + path='', + ) + path = body['path'] + with open(path, 'r') as f: + content = f.read() + filename = Path(path).name + mime, encoding = mimetypes.guess_type(path) + return send_success( + path=path, filename=filename, content=content, mime=mime, encoding=encoding + ) + except FileNotFoundError: + return send_error(status=404, reason='File not found', path=path) + except Exception as e: + return send_error(status=500, reason=str(e), path=body['path'] or '') + + +@routes.post('/comfylab/config_parse') +async def config_parse(request: Request): + try: + body = await request.json() + if not 'raw' in body.keys(): + return send_error( + status=500, + reason='Content missing in request', + ) + raw = body['raw'] + (type, data, prettified) = parse(raw) + except ParseError: + return send_error(status=415, reason='Malformed file') + except Exception as e: + return send_error(status=500, reason=str(e)) + return send_success(type=type, data=data, prettified=prettified) + + +@routes.post('/comfylab/config_convert') +async def config_convert(request: Request): + try: + body = await request.json() + if not 'data' in body.keys(): + return send_error( + status=500, + reason='Data missing in request', + ) + if not 'format' in body.keys(): + return send_error( + status=500, + reason='Format missing in request', + ) + data = body['data'] + format = body['format'] + prettified = convert(data, format) + except Exception as e: + return send_error(status=500, reason=str(e)) + return send_success(prettified=prettified) + + +@routes.post('/comfylab/config_validate') +async def config_validate(request: Request): + try: + body = await request.json() + if not 'raw' in body.keys(): + return send_error(status=500, reason='Raw data missing in request') + if not 'schema' in body.keys(): + return send_error(status=500, reason='Schema missing in request') + + raw = body['raw'] + schema_file = body['schema'] + (_, data, _) = parse(raw) + except ParseError: + return send_error(status=415, reason='Malformed data') + except Exception as e: + return send_error(status=500, reason=str(e), schema=schema_file) + + # validate JSON data + try: + (data, errors) = validate(data, schema_file) + return send_success(schema=schema_file, data=data, errors=errors) + except SchemaError as e: + # invalid schema + return send_error(status=500, reason=str(e), schema=schema_file) + except InvalidStructureError as e: + # invalid schema + return send_error( + status=415, + reason='Invalid structure', + schema=schema_file, + message=str(e), + ) + + +def load_api(): + # print('### ComfyLab: API loaded') + pass diff --git a/src/python/shared/grid.py b/src/python/shared/grid.py new file mode 100644 index 0000000..9f6ba78 --- /dev/null +++ b/src/python/shared/grid.py @@ -0,0 +1,295 @@ +from PIL import Image, ImageDraw, ImageFont +from pathlib import Path +import textwrap +import math +from dataclasses import asdict + +from .plot_data import PlotConfigGridData, PlotConfigHFData, PlotVars + +STATIC_DIR = Path(__file__).parent.parent.parent / 'static' + + +class Grid: + def __init__( + self, + plot_config_grid: PlotConfigGridData, + plot_config_header: PlotConfigHFData = None, + plot_config_footer: PlotConfigHFData = None, + ): + self.config_grid = plot_config_grid + self.config_header = plot_config_header + self.config_footer = plot_config_footer + self.headers = ([], []) + self.dims = (0, 0) + + def make( + self, + image_matrix: list[list[Image.Image]], + col_headers: list[str], + row_headers: list[str], + plot_vars: PlotVars, + ) -> Image.Image: + # keep a track to reuse later + self.headers = (col_headers, row_headers) + self.dims = (len(col_headers), len(row_headers)) + cols, rows = self.dims + self.max_cell_size = self._calc_max_cell_size(image_matrix) + + # build the grid image + grid_size = ( + self.max_cell_size[0] * cols + (cols - 1) * self.config_grid.gap, + self.max_cell_size[1] * rows + (rows - 1) * self.config_grid.gap, + ) + grid_image = self._create_image(grid_size, self.config_grid.background_color) + + for r, row in enumerate(image_matrix): + for c, image in enumerate(row): + x = c * (self.max_cell_size[0] + self.config_grid.gap) + y = r * (self.max_cell_size[1] + self.config_grid.gap) + grid_image.paste(image, (x, y)) + + # add headers; if header format for dim1/dim2 is empty, they will be silently ignored + grid_image = self._add_headers(grid_image) + + # add page header / footer + grid_image = self._add_page_hf(grid_image, plot_vars) + + return grid_image + + def _calc_max_cell_size( + self, image_matrix: list[list[Image.Image]] + ) -> tuple[int, int]: + # scan all images to get max width / max height + max_size = (-1, -1) + # TODO: allow different row heights / col widths? + for row in image_matrix: + for image in row: + w, h = image.size + max_size = (max(max_size[0], w), max(max_size[1], h)) + + return max_size + + def _create_image(self, size: tuple[int, int], bg_color: str) -> Image.Image: + if bg_color == 'transparent': + image = Image.new('RGBA', (size[0], size[1])) + else: + image = Image.new( + 'RGB', + (size[0], size[1]), + color=bg_color, + ) + return image + + def _add_headers(self, grid_image: Image.Image): + # normalize the headers, to respect the wrap configs + self.headers = ( + self._normalize_headers(self.headers[0], self.config_grid.wrap_col_headers), + self._normalize_headers(self.headers[1], self.config_grid.wrap_row_headers), + ) + + # load font + font = self._load_font(self.config_grid.font, self.config_grid.font_size) + + # calculate height and width of headers at top and left + top_margin, left_margin = self._calc_headers_margins(font) + + # build the new image and paste the existing grid + image = self._create_image( + (grid_image.size[0] + left_margin, grid_image.size[1] + top_margin), + self.config_grid.background_color, + ) + draw = ImageDraw.Draw(image) + draw.font = font + image.paste( + grid_image, + (image.size[0] - grid_image.size[0], image.size[1] - grid_image.size[1]), + ) + + # add the headers + for col, header in enumerate(self.headers[0]): + pos_x = ( + left_margin + + col * (self.config_grid.gap + self.max_cell_size[0]) + + self.max_cell_size[0] / 2 + ) + pos_y = top_margin / 2 + self._draw_header( + draw, (pos_x, pos_y), header, font, self.config_grid.font_color + ) + for row, header in enumerate(self.headers[1]): + pos_x = left_margin / 2 + pos_y = ( + top_margin + + row * (self.config_grid.gap + self.max_cell_size[1]) + + self.max_cell_size[1] / 2 + ) + self._draw_header( + draw, (pos_x, pos_y), header, font, self.config_grid.font_color + ) + return image + + def _load_font(self, font_name: str, font_size: int) -> ImageFont: + if not Path(font_name).is_absolute(): + font = ImageFont.truetype( + str(STATIC_DIR / font_name), + size=font_size, + ) + else: + font = ImageFont.truetype(str(Path(font_name)), size=font_size) + return font + + def _normalize_headers(self, headers: list[str], wrap: int) -> list[str]: + normalized = [] + for header in headers: + header = header.replace(r'\n', '\n') + if wrap > 0: + header = textwrap.fill(header, wrap, break_on_hyphens=True) + normalized.append(header) + return normalized + + def _calc_headers_margins(self, font: ImageFont): + top_margin = 0 + for header in self.headers[0]: + if header == '': + continue + lines = header.split('\n') + top_margin = max(top_margin, math.ceil(len(lines) * font.size)) + # add padding if there is something to display + if top_margin > 0: + top_margin = top_margin + 2 * self.config_grid.pad_col_headers + + left_margin = 0 + for header in self.headers[1]: + if header == '': + continue + for line in header.split('\n'): + left_margin = max(left_margin, math.ceil(font.getlength(line))) + # add padding if there is something to display + if left_margin > 0: + left_margin = left_margin + 2 * self.config_grid.pad_row_headers + + return (top_margin, left_margin) + + def _draw_header( + self, + draw: ImageDraw, + pos: tuple[int, int], + text: str, + font: ImageFont, + font_color, + ): + # see: https://github.com/python-pillow/Pillow/discussions/7914#discussioncomment-8950499 + draw.multiline_text( + pos, text, font=font, fill=font_color, align='center', anchor='mm' + ) + + def _add_page_hf(self, grid_image: Image.Image, plot_vars: PlotVars) -> Image.Image: + grid_width, grid_height = grid_image.size + header_height, header_image = self._draw_page_hf( + grid_width, plot_vars, self.config_header + ) + footer_height, footer_image = self._draw_page_hf( + grid_width, plot_vars, self.config_footer + ) + + # early exit + if header_height + footer_height == 0: + return grid_image + + # create a new image and paste grid and header / footer if applicable + new_image = self._create_image( + (grid_width, grid_height + header_height + footer_height), + self.config_grid.background_color, + ) + if header_image: + new_image.paste(header_image, (0, 0)) + new_image.paste(grid_image, (0, header_height)) + if footer_image: + new_image.paste(footer_image, (0, header_height + grid_height)) + + return new_image + + def _draw_page_hf( + self, width: int, plot_vars: PlotVars, config: PlotConfigHFData = None + ) -> tuple[int, Image.Image]: + # early exit + if not config or ( + not config.text_left and not config.text_center and not config.text_right + ): + return (0, None) + + # calc height + font = self._load_font(config.font, config.font_size) + texts = [ + self._apply_template(template, plot_vars) + for template in [config.text_left, config.text_center, config.text_right] + ] + height = 0 + for text in texts: + lines = text.split('\n') + height = max(height, math.ceil(len(lines) * font.size + 2 * config.padding)) + + # create the image + # if bg color is 'transparent', then keep the same as grid + image = self._create_image( + (width, height), + self.config_grid.background_color + if config.background_color == 'transparent' + else config.background_color, + ) + + # calculate the text position + texts_pos = [ + self._calc_page_hf_text_pos(align, (width, height), config.padding) + for align in ['left', 'center', 'right'] + ] + + # draw the texts + draw = ImageDraw.Draw(image) + draw.font = font + for i, text in enumerate(texts): + if not text: + continue + # see: https://github.com/python-pillow/Pillow/discussions/7914#discussioncomment-8950499 + # text anchors: https://pillow.readthedocs.io/en/stable/handbook/text-anchors.html + draw.multiline_text( + texts_pos[i][0], + text, + font=font, + fill=config.font_color, + align=texts_pos[i][1], + anchor=texts_pos[i][2], + ) + + return (height, image) + + def _apply_template(self, template: str, plot_vars: PlotVars) -> str: + text = template.replace(r'\n', '\n') + try: + text = text.format(**asdict(plot_vars)) + except KeyError as e: + text = "Error: unknown variable '{}'".format(e.args[0]) + return text + + def _calc_page_hf_text_pos( + self, align: str, size: tuple[int, int], padding: int + ) -> tuple[tuple[int, int], str, str]: + # calculate the text position + match align: + case 'left': + pos = (padding, size[1] // 2) + anchor = 'lm' + case 'right': + pos = (size[0] - padding, size[1] // 2) + anchor = 'rm' + case 'center': + pos = (size[0] // 2, size[1] // 2) + anchor = 'mm' + case _: + # probably useless + raise ValueError( + "invalid align value '{}': must be 'left', 'right' or 'center".format( + align + ) + ) + return (pos, align, anchor) diff --git a/src/python/shared/json_validation.py b/src/python/shared/json_validation.py new file mode 100644 index 0000000..c533bbb --- /dev/null +++ b/src/python/shared/json_validation.py @@ -0,0 +1,77 @@ +from pathlib import Path +import json +from jsonschema import Draft202012Validator # type: ignore + +SCHEMA_DIR = Path(__file__).parent.parent.parent / 'schema' + + +class SchemaError(Exception): + def __init__(self, message: str, schema: str): + super().__init__(message) + self.schema = schema + + +class InvalidStructureError(Exception): + def __init__(self, message: str): + super().__init__(message) + + +def validate(data, schema_file: str): + # load schema + schema_path = SCHEMA_DIR / '{}.schema.json'.format(schema_file) + try: + with open(schema_path, 'r') as f: + schema = json.load(f) + except FileNotFoundError: + raise SchemaError('Schema not found', schema_file) + except json.JSONDecodeError: + raise SchemaError('Invalid schema', schema_file) + except Exception as e: + raise SchemaError(str(e), schema_file) + + # validate each key against schema + # see: https://python-jsonschema.readthedocs.io/en/stable/errors/ + validator = Draft202012Validator(schema) + validationErrors = sorted(validator.iter_errors(data), key=lambda e: e.path) + + # first check is JSON structure is correct, early exit otherwise + if len(validationErrors) == 1 and len(validationErrors[0].absolute_path) == 0: + error = validationErrors[0] + message = ( + "expected type '{}'".format(error.validator_value) + if error.validator == 'type' + else '' + ) + raise InvalidStructureError(message) + + collected_errors = collect_errors(validationErrors) + return (data, collected_errors) + + +def collect_errors(errors): + collected = [] + for error in errors: + suberrors = ( + [] + if not error.context + else sorted(error.context, key=lambda e: e.schema_path) + ) + if len(suberrors) > 0: + collected += collect_errors(suberrors) + + if error.validator in ['oneOf', 'anyOf']: + continue + + if error.validator == 'required': + # collected.append(([error.validator_value[-1]], error.validator)) + collected.append( + ( + list(error.absolute_path) + [error.validator_value[-1]], + error.validator, + ) + ) + else: + if len(error.relative_path) > 0: # exclude validator 'not' + collected.append((list(error.absolute_path), error.validator)) + + return collected diff --git a/src/python/shared/pager.py b/src/python/shared/pager.py new file mode 100644 index 0000000..6fb4831 --- /dev/null +++ b/src/python/shared/pager.py @@ -0,0 +1,90 @@ +from types import SimpleNamespace +import torch # type: ignore +from .utils import tensor_to_pillow, pillow_to_tensor +from .plot_data import ( + XYPlotQueueData, + PlotConfigGridData, + PlotConfigHFData, + PlotVars, +) +from .grid import Grid + + +class Pager: + def __init__( + self, + xy_plot_data: XYPlotQueueData, + header_formats: tuple[str, str], + dim1_as_rows: bool = True, + ): + self.dim1_as_rows = dim1_as_rows + self.header_formats = header_formats + self.dim1 = SimpleNamespace( + **{'length': xy_plot_data.dim1.length, 'headers': []} + ) + self.dim2 = SimpleNamespace( + **{'length': xy_plot_data.dim2.length, 'headers': []} + ) + # initialize the 2D list + if dim1_as_rows: + self.image_matrix = [ + [None] * self.dim2.length for i in range(self.dim1.length) + ] + else: + self.image_matrix = [ + [None] * self.dim1.length for i in range(self.dim2.length) + ] + self.accumulated = 0 + + @property + def expected(self) -> int: + return self.dim1.length * self.dim2.length + + @property + def complete(self) -> bool: + return self.accumulated >= self.expected + + # calculate the coordinates in dim1 and dim2, given a sequential index + def get_coords(self, index: int) -> tuple[int, int]: + if self.dim1_as_rows: + return (int(index / self.dim2.length), int(index % self.dim2.length)) + else: + return (int(index % self.dim2.length), int(index / self.dim2.length)) + + def add(self, xy_plot_data: XYPlotQueueData, tensor: torch.Tensor): + # store dim1 / dim2 headers if not known yet + # TODO: catch exception and set default header? + if xy_plot_data.dim1.index >= len(self.dim1.headers): + self.dim1.headers.append( + self.header_formats[0].format(dim1=xy_plot_data.dim1.value) + ) + if xy_plot_data.dim2.index >= len(self.dim2.headers): + self.dim2.headers.append( + self.header_formats[1].format(dim2=xy_plot_data.dim2.value) + ) + + # store the tensor as image + x, y = self.get_coords(xy_plot_data.index) + self.image_matrix[x][y] = tensor_to_pillow(tensor) + self.accumulated += 1 + + # return complete status + return self.complete + + def make_grid( + self, + plot_vars: PlotVars, + plot_config_grid: PlotConfigGridData = PlotConfigGridData(), + plot_config_header: PlotConfigHFData = None, + plot_config_footer: PlotConfigHFData = None, + ) -> torch.Tensor: + grid = Grid(plot_config_grid, plot_config_header, plot_config_footer) + if self.dim1_as_rows: + grid_image = grid.make( + self.image_matrix, self.dim2.headers, self.dim1.headers, plot_vars + ) + else: + grid_image = grid.make( + self.image_matrix, self.dim1.headers, self.dim2.headers, plot_vars + ) + return pillow_to_tensor(grid_image) diff --git a/src/python/shared/plot_data.py b/src/python/shared/plot_data.py new file mode 100644 index 0000000..5028f23 --- /dev/null +++ b/src/python/shared/plot_data.py @@ -0,0 +1,52 @@ +from typing import Any +from dataclasses import dataclass + + +# store useful values associated with a dim +@dataclass +class DimData: + index: int + length: int + value: Any + + +# data sent from XYPlotQueue to XYPlotRender +@dataclass +class XYPlotQueueData: + index: int + current_page: str + total_pages: int + complete: bool + dim1: DimData + dim2: DimData + + +@dataclass +class PlotConfigGridData: + gap: int = 20 + background_color: str = '#b9b9b9' + font: str = 'Roboto-Regular.ttf' + font_size: int = 50 + font_color: str = '#444' + pad_col_headers: int = 30 + pad_row_headers: int = 50 + wrap_col_headers: int = 0 + wrap_row_headers: int = 0 + + +@dataclass +class PlotConfigHFData: + text_left: str = '' + text_center: str = '' + text_right: str = '' + background_color: str = 'transparent' + font: str = 'Roboto-Bold.ttf' + font_size: int = 60 + font_color: str = '#222' + padding: int = 30 + + +@dataclass +class PlotVars: + current_page: int + total_pages: int diff --git a/src/python/shared/utils.py b/src/python/shared/utils.py new file mode 100644 index 0000000..c3fba49 --- /dev/null +++ b/src/python/shared/utils.py @@ -0,0 +1,46 @@ +import torch # type: ignore +from PIL import Image +import numpy as np + + +class AnyType(str): + def __ne__(self, __value: object) -> bool: + return False + + +ANY_TYPE = AnyType('*') + + +class AnyReturnTypes(tuple): + def __getitem__(self, key): + return ANY_TYPE + + +def tensor_to_pillow(tensor: torch.tensor) -> Image.Image: + return Image.fromarray( + np.clip(255.0 * tensor.cpu().numpy().squeeze(), 0, 255).astype(np.uint8) + ) + + +def pillow_to_tensor(image: Image.Image) -> torch.tensor: + return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0) + + +class EmptyNode: + def __init__(self): + pass + + @classmethod + def INPUT_TYPES(s): + return { + 'required': {}, + 'optional': {}, + } + + FUNCTION = 'run' + RETURN_TYPES = () + + DESCRIPTION = 'This is an empty node. Not useless though.' + + def run(self): + pass diff --git a/src/schema/config.multi.schema.json b/src/schema/config.multi.schema.json new file mode 100644 index 0000000..88153ef --- /dev/null +++ b/src/schema/config.multi.schema.json @@ -0,0 +1,10 @@ +{ + "$schema": "http://json-schema.org/draft-04/schema#", + "type": "object", + "additionalProperties": { + "type": "object", + "additionalProperties": { + "type": ["string", "number", "boolean"] + } + } +} diff --git a/src/schema/config.node.schema.json b/src/schema/config.node.schema.json new file mode 100644 index 0000000..5538969 --- /dev/null +++ b/src/schema/config.node.schema.json @@ -0,0 +1,7 @@ +{ + "$schema": "http://json-schema.org/draft-04/schema#", + "type": "object", + "additionalProperties": { + "type": ["string", "number", "boolean"] + } +} diff --git a/src/schema/config.output.auto.schema.json b/src/schema/config.output.auto.schema.json new file mode 100644 index 0000000..8ac4817 --- /dev/null +++ b/src/schema/config.output.auto.schema.json @@ -0,0 +1,27 @@ +{ + "$schema": "http://json-schema.org/draft-04/schema#", + "type": "object", + "additionalProperties": { + "oneOf": [ + { "not": { "type": "object" } }, + { + "type": "object", + "properties": { + "value": {}, + "type": { + "type": ["string", "array"], + "items": { "type": "string" } + }, + "label": { "type": "string" }, + "tooltip": { "type": "string" }, + "color_off": { "type": "string" }, + "color_on": { "type": "string" }, + "shape": { "enum": ["box", "circle", "arrow", "grid"] }, + "node": { "type": ["integer", "string"] } + }, + "required": ["value"], + "additionalProperties": true + } + ] + } +} diff --git a/src/schema/config.output.schema.json b/src/schema/config.output.schema.json new file mode 100644 index 0000000..3a7ff52 --- /dev/null +++ b/src/schema/config.output.schema.json @@ -0,0 +1,26 @@ +{ + "$schema": "http://json-schema.org/draft-04/schema#", + "type": "object", + "additionalProperties": { + "oneOf": [ + { "not": { "type": "object" } }, + { + "type": "object", + "properties": { + "value": {}, + "type": { + "type": ["string", "array"], + "items": { "type": "string" } + }, + "label": { "type": "string" }, + "tooltip": { "type": "string" }, + "color_off": { "type": "string" }, + "color_on": { "type": "string" }, + "shape": { "enum": ["box", "circle", "arrow", "grid"] } + }, + "required": ["value"], + "additionalProperties": true + } + ] + } +} diff --git a/src/ts/.d.ts/comfyui-frontend-types_alt.d.ts b/src/ts/.d.ts/comfyui-frontend-types_alt.d.ts new file mode 100644 index 0000000..87b5797 --- /dev/null +++ b/src/ts/.d.ts/comfyui-frontend-types_alt.d.ts @@ -0,0 +1,97734 @@ +import { Component } from 'vue' +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 { RenderShape } from '@comfyorg/litegraph/dist/types/globalEnums' +import { Vector2 } from '@comfyorg/litegraph' +import { z } from 'zod' + +export declare function $el( + tag: TTag, + propsOrChildren?: Children | Props, + children?: Children, +): ElementType + +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` */ +declare type ApiEvents = AsCustomEvents + +/** Dictionary of types used in the detail for a custom event */ +declare type ApiEventTypes = ApiToEventType + +/** Handles differing event and API signatures. */ +declare type ApiToEventType = { + [K in keyof T]: K extends 'status' + ? StatusWsMessageStatus + : K extends 'executing' + ? NodeId + : T[K] +} + +/** Wraps all properties in {@link CustomEvent}. */ +declare type AsCustomEvents = { + readonly [K in keyof T]: CustomEvent +} + +/** 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_cached: ExecutionCachedWsMessage + logs: LogsWsMessage + /** Mr Blob Preview, I presume? */ + b_preview: Blob +} + +declare interface BaseBottomPanelExtension { + id: string + title: string +} + +declare interface BaseInputSpec { + name: string + type: string + tooltip?: string + default?: T + forceInput?: boolean +} + +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 + 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 + undo(): Promise + redo(): Promise + undoRedo(e: KeyboardEvent): Promise + 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 Children = Element[] | Element | string | string[] + +declare type ClassList = string | string[] | Record + +declare type Clipspace = { + widgets?: + | { + type?: string + name?: string + value?: any + }[] + | null + imgs?: HTMLImageElement[] | null + original_imgs?: HTMLImageElement[] | null + images?: any[] | null + selectedIndex: number + img_paste_mode: string +} + +/** EventTarget typing has no generic capability. This interface enables tsc strict. */ +declare interface ComfyApi extends EventTarget { + addEventListener( + type: TEvent, + callback: ((event: ApiEvents[TEvent]) => void) | null, + options?: AddEventListenerOptions | boolean, + ): void + removeEventListener( + type: TEvent, + callback: ((event: ApiEvents[TEvent]) => void) | null, + options?: EventListenerOptions | boolean, + ): void +} + +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 + constructor() + internalURL(route: string): string + apiURL(route: string): string + fileURL(route: string): string + fetchApi(route: string, options?: RequestInit): Promise + /** + * 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(type: T): boolean + dispatchCustomEvent( + 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 + /** + * Gets a list of embedding names + */ + getEmbeddings(): Promise + /** + * Loads node object definitions for the graph + * @returns The node definitions + */ + getNodeDefs({ + validate, + }?: { + validate?: boolean + }): Promise> + /** + * + * @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 + workflow: ComfyWorkflowJSON + }, + ): Promise + /** + * 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 + /** + * 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 + /** + * 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 + /** + * Clears the specified list + * @param {string} type The type of list to clear, queue or history + */ + clearItems(type: string): Promise + /** + * Interrupts the execution of the running prompt + */ + interrupt(): Promise + /** + * Gets user configuration data and where data should be stored + */ + getUserConfig(): Promise + /** + * Creates a new user + * @param { string } username + * @returns The fetch response + */ + createUser(username: string): Promise + /** + * Gets all setting values for the current user + * @returns { Promise } A dictionary of id -> value + */ + getSettings(): Promise + /** + * Gets a setting for the current user + * @param { string } id The id of the setting to fetch + * @returns { Promise } The setting value + */ + getSetting(id: keyof Settings): Promise + /** + * Stores a dictionary of settings for the current user + */ + storeSettings(settings: Settings): Promise + /** + * Stores a setting for the current user + */ + storeSetting( + id: keyof Settings, + value: Settings[keyof Settings], + ): Promise + /** + * Gets a user data file for the current user + */ + getUserData(file: string, options?: RequestInit): Promise + /** + * 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 } + */ + storeUserData( + file: string, + data: any, + options?: RequestInit & { + overwrite?: boolean + stringify?: boolean + throwOnError?: boolean + full_info?: boolean + }, + ): Promise + /** + * Deletes a user data file for the current user + * @param { string } file The name of the userdata file to delete + */ + deleteUserData(file: string): Promise + /** + * 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 + /** + * @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 } 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 } The list of files + */ + listUserData(dir: string, recurse: boolean, split?: true): Promise + listUserData(dir: string, recurse: boolean, split?: false): Promise + listUserDataFullInfo(dir: string): Promise + getLogs(): Promise + getRawLogs(): Promise + subscribeLogs(enabled: boolean): Promise + getFolderPaths(): Promise> +} + +/** + * @typedef {import("types/comfy").ComfyExtension} ComfyExtension + */ +declare class ComfyApp { + #private + /** + * Content Clipboard + * @type {serialized node object} + */ + static clipspace: Clipspace | null + static clipspace_invalidate_handler: (() => void) | null + static open_maskeditor: any + static clipspace_return_node: any + vueAppReady: boolean + api: ComfyApi + ui: ComfyUI + extensionManager: ExtensionManager + _nodeOutputs: Record + nodePreviewImages: Record + graph: LGraph + canvas: LGraphCanvas + dragOverNode: LGraphNode | null + canvasEl: HTMLCanvasElement + zoom_drag_start: [number, number, number] | null + 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 + /** + * @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 + } + constructor() + get nodeOutputs(): Record + set nodeOutputs(value: Record) + getPreviewFormatParam(): string + getRandParam(): string + static isImageNode(node: any): any + static onClipspaceEditorSave(): void + static onClipspaceEditorClosed(): void + static copyToClipspace(node: any): void + static pasteFromClipspace(node: any): void + /** + * Set up the app on the page + */ + setup(canvasEl: HTMLCanvasElement): Promise + resizeCanvas(): void + private updateVueAppNodeDefs + /** + * Registers nodes with the graph + */ + registerNodes(): Promise + /** + * Remove the impl after groupNode jest tests are removed. + * @deprecated Use useWidgetStore().getWidgetType instead + */ + getWidgetType(inputData: any, inputName: string): any + registerNodeDef(nodeId: string, nodeData: ComfyNodeDef): Promise + registerNodesFromDefs(defs: Record): Promise + loadTemplateData(templateData: any): void + loadGraphData( + graphData?: ComfyWorkflowJSON, + clean?: boolean, + restore_view?: boolean, + workflow?: string | null | ComfyWorkflow, + { + showMissingNodesDialog, + showMissingModelsDialog, + }?: { + showMissingNodesDialog?: boolean + showMissingModelsDialog?: boolean + }, + ): Promise + /** + * 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 + /** + * Converts the current graph workflow for sending to the API. + * Note: Node widgets are updated before serialization to prepare queueing. + * @returns The workflow and node links + */ + graphToPrompt( + graph?: LGraph, + clean?: boolean, + ): Promise<{ + workflow: ISerialisedGraph + output: {} + }> + queuePrompt(number: any, batchCount?: number): Promise + showErrorOnFileLoad(file: any): void + /** + * Loads workflow data from the specified file + * @param {File} file + */ + handleFile(file: any): Promise + 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 + resetView(): 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 + addNodeOnGraph( + nodeDef: ComfyNodeDef | ComfyNodeDefImpl, + options?: Record, + ): LGraphNode + clientPosToCanvasPos(pos: Vector2): Vector2 + canvasPosToClientPos(pos: Vector2): Vector2 + getCanvasCenter(): Vector2 + goToNode(nodeId: NodeId): void +} + +declare class ComfyAppMenu { + app: ComfyApp + actionsGroup: ComfyButtonGroup + settingsGroup: ComfyButtonGroup + viewGroup: ComfyButtonGroup + element: HTMLElement + constructor(app: ComfyApp) +} + +export declare class ComfyAsyncDialog extends ComfyDialog { + #private + constructor( + actions?: Array< + | string + | { + value?: any + text: string + } + >, + ) + show(html: string | HTMLElement | HTMLElement[]): Promise + showModal(html: string | HTMLElement | HTMLElement[]): Promise + close(result?: any): void + static prompt({ + title, + message, + actions, + }: { + title: string | null + message: string + actions: Array< + | string + | { + value?: any + text: string + } + > + }): Promise +} + +declare class ComfyButton implements ComfyComponent { + #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)[] + 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 + showValue: boolean + } + app?: ComfyApp +} + +declare interface ComfyCommand { + id: string + function: () => void | Promise + 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 { + element: T +} + +declare class ComfyDialog< + T extends HTMLElement = HTMLElement, +> extends EventTarget { + #private + element: T + textElement: HTMLElement + constructor(type?: string, buttons?: any) + createButtons(): HTMLButtonElement[] + close(): void + show(html: any): void +} + +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 + /** + * 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 + /** + * 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, + app: ComfyApp, + ): Promise | 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 + /** + * 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 + /** + * 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 + /** + * 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 + /** + * Allows the extension to run code after the graph is configured. + * @param missingNodeTypes The missing node types + */ + afterConfigureGraph?( + missingNodeTypes: MissingNodeType[], + ): Promise | void + [key: string]: any +} + +declare type ComfyInputsSpec = z.infer + +declare class ComfyInputsSpec_2 { + required: Record + optional: Record + hidden?: Record + constructor(obj: ComfyInputsSpec) + private static transformInputSpecRecord + private static isInputSpec + private static transformSingleInputSpec + get all(): BaseInputSpec[] + getInput(name: string): BaseInputSpec | undefined +} + +declare class ComfyList { + #private + element: HTMLDivElement + button?: HTMLButtonElement + constructor(text: any, type?: any, reverse?: any) + get visible(): boolean + load(): Promise + update(): Promise + show(): Promise + hide(): void + toggle(): boolean +} + +export declare type ComfyNodeDef = z.infer + +declare class ComfyNodeDefImpl implements ComfyNodeDef { + readonly name: string + readonly display_name: string + /** + * Category is not marked as readonly as the bookmark system + * needs to write to it to assign a node to a custom folder. + */ + category: string + readonly python_module: string + readonly description: string + readonly deprecated: boolean + readonly experimental: boolean + readonly output_node: boolean + /** + * @deprecated Use `inputs` instead + */ + readonly input: ComfyInputsSpec + /** + * @deprecated Use `outputs` instead + */ + readonly output: ComfyOutputTypesSpec + /** + * @deprecated Use `outputs[n].is_list` instead + */ + readonly output_is_list?: boolean[] + /** + * @deprecated Use `outputs[n].name` instead + */ + readonly output_name?: string[] + /** + * @deprecated Use `outputs[n].tooltip` instead + */ + readonly output_tooltips?: string[] + readonly inputs: ComfyInputsSpec_2 + readonly outputs: ComfyOutputsSpec + readonly nodeSource: NodeSource + constructor(obj: ComfyNodeDef) + private static transformOutputSpec + get nodePath(): string + get isDummyFolder(): boolean + postProcessSearchScores(scores: SearchAuxScore): SearchAuxScore + get isCoreNode(): boolean + get nodeLifeCycleBadgeText(): string +} + +declare class ComfyOutputSpec { + index: number + name: string + type: string + is_list: boolean + comboOptions?: any[] + tooltip?: string + constructor( + index: number, + name: string, + type: string, + is_list: boolean, + comboOptions?: any[], + tooltip?: string, + ) +} + +declare class ComfyOutputsSpec { + outputs: ComfyOutputSpec[] + constructor(outputs: ComfyOutputSpec[]) + get all(): ComfyOutputSpec[] +} + +declare type ComfyOutputTypesSpec = z.infer + +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 { + #private + app: ComfyApp + settingsValues: any + settingsLookup: Record + settingsParamLookup: Record + constructor(app: ComfyApp) + get settings(): Setting[] + private tryMigrateDeprecatedValue + load(): Promise + getSettingValue( + id: K, + defaultValue?: Settings[K], + ): Settings[K] + getSettingDefaultValue(id: string): any + setSettingValueAsync( + id: K, + value: Settings[K], + ): Promise + setSettingValue(id: K, value: Settings[K]): void + refreshSetting(id: keyof Settings): void + /** + * 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 +} + +export declare const ComfyWidgets: Record + +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 + unload(): void + save(): Promise + /** + * 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 +} + +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 + +declare type CustomBottomPanelExtension = BaseBottomPanelExtension & + CustomExtension + +declare interface CustomExtension { + id: string + type: 'custom' + render: (container: HTMLElement) => void + destroy?: () => void +} + +declare type CustomSidebarTabExtension = BaseSidebarTabExtension & + CustomExtension + +declare type ElementType = + K extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[K] : HTMLElement + +declare type EmbeddingsResponse = z.infer + +export declare type ExecutedWsMessage = z.infer + +export declare type ExecutingWsMessage = z.infer + +export declare type ExecutionCachedWsMessage = z.infer< + typeof zExecutionCachedWsMessage +> + +export declare type ExecutionErrorWsMessage = z.infer< + typeof zExecutionErrorWsMessage +> + +export declare type ExecutionStartWsMessage = z.infer< + typeof zExecutionStartWsMessage +> + +export declare type ExecutionSuccessWsMessage = z.infer< + typeof zExecutionSuccessWsMessage +> + +declare interface ExtensionManager { + registerSidebarTab(tab: SidebarTabExtension): void + unregisterSidebarTab(id: string): void + getSidebarTabs(): SidebarTabExtension[] + toast: ToastManager + command: CommandManager + setting: { + get: (id: string) => any + set: (id: string, value: any) => void + } +} + +declare type ExtensionsResponse = z.infer + +/** + * The base form item for rendering in a form. + */ +declare interface FormItem { + name: string + type: SettingInputType | SettingCustomRenderer + tooltip?: string + attrs?: Record + options?: Array +} + +/** Dictionary of Frontend-generated API calls */ +declare interface FrontendApiCalls { + graphChanged: ComfyWorkflowJSON + promptQueued: { + number: number + batchCount: number + } + graphCleared: never + reconnecting: never + reconnected: never +} + +declare type HistoryTaskItem = z.infer + +export declare type InputSpec = z.infer + +declare type Keybinding = z.infer + +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 LogsRawResponse = z.infer + +export declare type LogsWsMessage = z.infer + +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 = { + [K in keyof T as T[K] extends never ? never : K]: T[K] +} + +declare type NodeId = z.infer + +declare type NodeSource = { + type: NodeSourceType + className: string + displayText: string + badgeText: string +} + +declare enum NodeSourceType { + Core = 'core', + CustomNodes = 'custom_nodes', + Unknown = 'unknown', +} + +declare type PendingTaskItem = z.infer + +/** {@link Pick} only properties that evaluate to `never`. */ +declare type PickNevers = { + [K in keyof T as T[K] extends never ? K : never]: T[K] +} + +export declare type ProgressWsMessage = z.infer + +declare type PromptResponse = z.infer + +declare type Props = { + parent?: HTMLElement + $?: (el: HTMLElement) => void + dataset?: DOMStringMap + style?: Partial + for?: string + textContent?: string + [key: string]: any +} + +declare type RunningTaskItem = z.infer + +declare type SearchAuxScore = number[] + +declare interface Setting { + id: keyof Settings + onChange?: (value: any, oldValue?: any) => void + name: string + render: () => HTMLElement +} + +declare type SettingCustomRenderer = ( + name: string, + setter: (v: any) => void, + value: any, + attrs: any, +) => HTMLElement + +declare type SettingInputType = + | 'boolean' + | 'number' + | 'slider' + | 'combo' + | 'text' + | 'image' + | 'color' + | '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 Settings = z.infer + +declare type SidebarTabExtension = + | VueSidebarTabExtension + | CustomSidebarTabExtension + +/** Keys (names) of API events that _do not_ pass a {@link CustomEvent} `detail` object. */ +declare type SimpleApiEvents = keyof PickNevers + +export declare type StatusWsMessage = z.infer + +declare type StatusWsMessageStatus = z.infer + +declare type SystemStats = z.infer + +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 type User = z.infer + +declare type UserDataFullInfo = z.infer + +/** + * 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 + /** + * Unloads the file content from memory + */ + unload(): void + saveAs(newPath: string): Promise + /** + * 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 + delete(): Promise + rename(newPath: string): Promise +} + +declare type VueBottomPanelExtension = BaseBottomPanelExtension & VueExtension + +declare interface VueExtension { + id: string + type: 'vue' + component: Component +} + +declare type VueSidebarTabExtension = BaseSidebarTabExtension & VueExtension + +declare type Widgets = Record + +declare const zComfyInputsSpec: z.ZodObject< + { + required: z.ZodOptional< + z.ZodRecord< + z.ZodString, + z.ZodUnion< + [ + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'INT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'INT'>], null>, + ('INT' | {})[], + ['INT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'INT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'FLOAT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'FLOAT'>], null>, + ('FLOAT' | {})[], + ['FLOAT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'FLOAT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'BOOLEAN'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'BOOLEAN'>], null>, + ('BOOLEAN' | {})[], + ['BOOLEAN', ...unknown[]] + >, + ...z.ZodEffects, any[], 'BOOLEAN'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'STRING'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'STRING'>], null>, + ('STRING' | {})[], + ['STRING', ...unknown[]] + >, + ...z.ZodEffects, any[], 'STRING'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodArray, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodArray], null>, + (any[] | {})[], + [any[], ...unknown[]] + >, + ...z.ZodEffects, any[], any[]>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodEffects, + z.ZodObject< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodEffects], null>, + (string | {})[], + [string, ...unknown[]] + >, + ...z.ZodEffects< + z.ZodEffects, + any[], + string + >[], + ] + >, + ] + > + > + > + optional: z.ZodOptional< + z.ZodRecord< + z.ZodString, + z.ZodUnion< + [ + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'INT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'INT'>], null>, + ('INT' | {})[], + ['INT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'INT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'FLOAT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'FLOAT'>], null>, + ('FLOAT' | {})[], + ['FLOAT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'FLOAT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'BOOLEAN'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'BOOLEAN'>], null>, + ('BOOLEAN' | {})[], + ['BOOLEAN', ...unknown[]] + >, + ...z.ZodEffects, any[], 'BOOLEAN'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'STRING'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'STRING'>], null>, + ('STRING' | {})[], + ['STRING', ...unknown[]] + >, + ...z.ZodEffects, any[], 'STRING'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodArray, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodArray], null>, + (any[] | {})[], + [any[], ...unknown[]] + >, + ...z.ZodEffects, any[], any[]>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodEffects, + z.ZodObject< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodEffects], null>, + (string | {})[], + [string, ...unknown[]] + >, + ...z.ZodEffects< + z.ZodEffects, + any[], + string + >[], + ] + >, + ] + > + > + > + hidden: z.ZodOptional> + }, + 'strip', + z.ZodTypeAny, + { + required?: Record< + string, + | any[] + | ('INT' | {})[] + | ('FLOAT' | {})[] + | ('BOOLEAN' | {})[] + | ('STRING' | {})[] + | (any[] | {})[] + | (string | {})[] + | [ + 'INT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + hidden?: Record + optional?: Record< + string, + | any[] + | ('INT' | {})[] + | ('FLOAT' | {})[] + | ('BOOLEAN' | {})[] + | ('STRING' | {})[] + | (any[] | {})[] + | (string | {})[] + | [ + 'INT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + }, + { + required?: Record< + string, + | string + | any[] + | ['INT', ...unknown[]] + | ['FLOAT', ...unknown[]] + | ['BOOLEAN', ...unknown[]] + | ['STRING', ...unknown[]] + | [any[], ...unknown[]] + | [string, ...unknown[]] + | [ + 'INT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + hidden?: Record + optional?: Record< + string, + | string + | any[] + | ['INT', ...unknown[]] + | ['FLOAT', ...unknown[]] + | ['BOOLEAN', ...unknown[]] + | ['STRING', ...unknown[]] + | [any[], ...unknown[]] + | [string, ...unknown[]] + | [ + 'INT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + } +> + +declare const zComfyNodeDef: z.ZodObject< + { + input: z.ZodOptional< + z.ZodObject< + { + required: z.ZodOptional< + z.ZodRecord< + z.ZodString, + z.ZodUnion< + [ + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'INT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'INT'>], null>, + ('INT' | {})[], + ['INT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'INT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'FLOAT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodLiteral] + > + > + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodLiteral] + > + > + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'FLOAT'>], null>, + ('FLOAT' | {})[], + ['FLOAT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'FLOAT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'BOOLEAN'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'BOOLEAN'>], null>, + ('BOOLEAN' | {})[], + ['BOOLEAN', ...unknown[]] + >, + ...z.ZodEffects< + z.ZodLiteral<'BOOLEAN'>, + any[], + 'BOOLEAN' + >[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'STRING'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'STRING'>], null>, + ('STRING' | {})[], + ['STRING', ...unknown[]] + >, + ...z.ZodEffects< + z.ZodLiteral<'STRING'>, + any[], + 'STRING' + >[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodArray, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodArray], null>, + (any[] | {})[], + [any[], ...unknown[]] + >, + ...z.ZodEffects< + z.ZodArray, + any[], + any[] + >[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodEffects, + z.ZodObject< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple< + [z.ZodEffects], + null + >, + (string | {})[], + [string, ...unknown[]] + >, + ...z.ZodEffects< + z.ZodEffects, + any[], + string + >[], + ] + >, + ] + > + > + > + optional: z.ZodOptional< + z.ZodRecord< + z.ZodString, + z.ZodUnion< + [ + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'INT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'INT'>], null>, + ('INT' | {})[], + ['INT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'INT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'FLOAT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodLiteral] + > + > + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodLiteral] + > + > + default: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodArray, + ] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'FLOAT'>], null>, + ('FLOAT' | {})[], + ['FLOAT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'FLOAT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'BOOLEAN'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'BOOLEAN'>], null>, + ('BOOLEAN' | {})[], + ['BOOLEAN', ...unknown[]] + >, + ...z.ZodEffects< + z.ZodLiteral<'BOOLEAN'>, + any[], + 'BOOLEAN' + >[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'STRING'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'STRING'>], null>, + ('STRING' | {})[], + ['STRING', ...unknown[]] + >, + ...z.ZodEffects< + z.ZodLiteral<'STRING'>, + any[], + 'STRING' + >[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodArray, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodArray], null>, + (any[] | {})[], + [any[], ...unknown[]] + >, + ...z.ZodEffects< + z.ZodArray, + any[], + any[] + >[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodEffects, + z.ZodObject< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple< + [z.ZodEffects], + null + >, + (string | {})[], + [string, ...unknown[]] + >, + ...z.ZodEffects< + z.ZodEffects, + any[], + string + >[], + ] + >, + ] + > + > + > + hidden: z.ZodOptional> + }, + 'strip', + z.ZodTypeAny, + { + required?: Record< + string, + | any[] + | ('INT' | {})[] + | ('FLOAT' | {})[] + | ('BOOLEAN' | {})[] + | ('STRING' | {})[] + | (any[] | {})[] + | (string | {})[] + | [ + 'INT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + hidden?: Record + optional?: Record< + string, + | any[] + | ('INT' | {})[] + | ('FLOAT' | {})[] + | ('BOOLEAN' | {})[] + | ('STRING' | {})[] + | (any[] | {})[] + | (string | {})[] + | [ + 'INT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + }, + { + required?: Record< + string, + | string + | any[] + | ['INT', ...unknown[]] + | ['FLOAT', ...unknown[]] + | ['BOOLEAN', ...unknown[]] + | ['STRING', ...unknown[]] + | [any[], ...unknown[]] + | [string, ...unknown[]] + | [ + 'INT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + hidden?: Record + optional?: Record< + string, + | string + | any[] + | ['INT', ...unknown[]] + | ['FLOAT', ...unknown[]] + | ['BOOLEAN', ...unknown[]] + | ['STRING', ...unknown[]] + | [any[], ...unknown[]] + | [string, ...unknown[]] + | [ + 'INT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion< + [z.ZodNumber, z.ZodArray] + > + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + } + > + > + output: z.ZodOptional< + z.ZodArray< + z.ZodUnion<[z.ZodString, z.ZodArray]>, + 'many' + > + > + output_is_list: z.ZodOptional> + output_name: z.ZodOptional> + output_tooltips: z.ZodOptional> + name: z.ZodString + display_name: z.ZodString + description: z.ZodString + category: z.ZodString + output_node: z.ZodBoolean + python_module: z.ZodString + deprecated: z.ZodOptional + experimental: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + name?: string + description?: string + output?: (string | any[])[] + input?: { + required?: Record< + string, + | any[] + | ('INT' | {})[] + | ('FLOAT' | {})[] + | ('BOOLEAN' | {})[] + | ('STRING' | {})[] + | (any[] | {})[] + | (string | {})[] + | [ + 'INT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + hidden?: Record + optional?: Record< + string, + | any[] + | ('INT' | {})[] + | ('FLOAT' | {})[] + | ('BOOLEAN' | {})[] + | ('STRING' | {})[] + | (any[] | {})[] + | (string | {})[] + | [ + 'INT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + } + output_is_list?: boolean[] + output_name?: string[] + output_tooltips?: string[] + display_name?: string + category?: string + output_node?: boolean + python_module?: string + deprecated?: boolean + experimental?: boolean + }, + { + name?: string + description?: string + output?: (string | any[])[] + input?: { + required?: Record< + string, + | string + | any[] + | ['INT', ...unknown[]] + | ['FLOAT', ...unknown[]] + | ['BOOLEAN', ...unknown[]] + | ['STRING', ...unknown[]] + | [any[], ...unknown[]] + | [string, ...unknown[]] + | [ + 'INT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + hidden?: Record + optional?: Record< + string, + | string + | any[] + | ['INT', ...unknown[]] + | ['FLOAT', ...unknown[]] + | ['BOOLEAN', ...unknown[]] + | ['STRING', ...unknown[]] + | [any[], ...unknown[]] + | [string, ...unknown[]] + | [ + 'INT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'FLOAT', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'BOOLEAN', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + 'STRING', + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + any[], + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + | [ + string, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + ...unknown[], + ] + > + } + output_is_list?: boolean[] + output_name?: string[] + output_tooltips?: string[] + display_name?: string + category?: string + output_node?: boolean + python_module?: string + deprecated?: boolean + experimental?: boolean + } +> + +declare const zComfyOutputTypesSpec: z.ZodArray< + z.ZodUnion<[z.ZodString, z.ZodArray]>, + 'many' +> + +/** Schema version 0.4 */ +declare const zComfyWorkflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [z.ZodArray, z.ZodRecord] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > +> + +/** Schema version 1 */ +declare const zComfyWorkflow1: z.ZodObject< + { + version: z.ZodLiteral<1> + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + > + state: z.ZodObject< + { + lastGroupid: z.ZodOptional + lastNodeId: z.ZodOptional + lastLinkId: z.ZodOptional + lastRerouteId: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + lastGroupid: z.ZodOptional + lastNodeId: z.ZodOptional + lastLinkId: z.ZodOptional + lastRerouteId: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + lastGroupid: z.ZodOptional + lastNodeId: z.ZodOptional + lastLinkId: z.ZodOptional + lastRerouteId: z.ZodOptional + }, + 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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [z.ZodArray, z.ZodRecord] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + > + target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + target_slot: z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + parentId: z.ZodOptional + }, + '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, + number, + string + >, + ] + > + target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + target_slot: z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + parentId: z.ZodOptional + }, + 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, + number, + string + >, + ] + > + target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + target_slot: z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + parentId: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + reroutes: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + > + models: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + url: z.ZodString + hash: z.ZodOptional + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + version: z.ZodLiteral<1> + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + > + state: z.ZodObject< + { + lastGroupid: z.ZodOptional + lastNodeId: z.ZodOptional + lastLinkId: z.ZodOptional + lastRerouteId: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + lastGroupid: z.ZodOptional + lastNodeId: z.ZodOptional + lastLinkId: z.ZodOptional + lastRerouteId: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + lastGroupid: z.ZodOptional + lastNodeId: z.ZodOptional + lastLinkId: z.ZodOptional + lastRerouteId: z.ZodOptional + }, + 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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + > + target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + target_slot: z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + parentId: z.ZodOptional + }, + '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, + number, + string + >, + ] + > + target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + target_slot: z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + parentId: z.ZodOptional + }, + 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, + number, + string + >, + ] + > + target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + target_slot: z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + parentId: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + reroutes: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + > + models: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + url: z.ZodString + hash: z.ZodOptional + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + version: z.ZodLiteral<1> + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + > + state: z.ZodObject< + { + lastGroupid: z.ZodOptional + lastNodeId: z.ZodOptional + lastLinkId: z.ZodOptional + lastRerouteId: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + lastGroupid: z.ZodOptional + lastNodeId: z.ZodOptional + lastLinkId: z.ZodOptional + lastRerouteId: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + lastGroupid: z.ZodOptional + lastNodeId: z.ZodOptional + lastLinkId: z.ZodOptional + lastRerouteId: z.ZodOptional + }, + 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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + > + target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + target_slot: z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + parentId: z.ZodOptional + }, + '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, + number, + string + >, + ] + > + target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + target_slot: z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + parentId: z.ZodOptional + }, + 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, + number, + string + >, + ] + > + target_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + target_slot: z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + type: z.ZodUnion< + [z.ZodString, z.ZodArray, z.ZodNumber] + > + parentId: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + reroutes: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 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[], + 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[], + 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[], + 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 + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + > + models: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + url: z.ZodString + hash: z.ZodOptional + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > +> + +declare const zEmbeddingsResponse: z.ZodArray + +declare const zExecutedWsMessage: z.ZodObject< + z.objectUtil.extendShape< + { + node: z.ZodUnion<[z.ZodNumber, z.ZodString]> + display_node: z.ZodUnion<[z.ZodNumber, z.ZodString]> + prompt_id: z.ZodString + }, + { + output: z.ZodObject< + { + audio: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + images: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + animated: z.ZodOptional> + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + audio: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + images: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + animated: z.ZodOptional> + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + audio: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + images: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + animated: z.ZodOptional> + }, + z.ZodTypeAny, + 'passthrough' + > + > + merge: z.ZodOptional + } + >, + 'strip', + z.ZodTypeAny, + { + prompt_id?: string + node?: string | number + display_node?: string | number + output?: { + audio?: { + type?: string + filename?: string + subfolder?: string + }[] + images?: { + type?: string + filename?: string + subfolder?: string + }[] + animated?: boolean[] + } & { + [k: string]: unknown + } + merge?: boolean + }, + { + prompt_id?: string + node?: string | number + display_node?: string | number + output?: { + audio?: { + type?: string + filename?: string + subfolder?: string + }[] + images?: { + type?: string + filename?: string + subfolder?: string + }[] + animated?: boolean[] + } & { + [k: string]: unknown + } + merge?: boolean + } +> + +declare const zExecutingWsMessage: z.ZodObject< + { + node: z.ZodUnion<[z.ZodNumber, z.ZodString]> + display_node: z.ZodUnion<[z.ZodNumber, z.ZodString]> + prompt_id: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + prompt_id?: string + node?: string | number + display_node?: string | number + }, + { + prompt_id?: string + node?: string | number + display_node?: string | number + } +> + +declare const zExecutionCachedWsMessage: z.ZodObject< + z.objectUtil.extendShape< + { + prompt_id: z.ZodString + timestamp: z.ZodNumber + }, + { + nodes: z.ZodArray, 'many'> + } + >, + 'strip', + z.ZodTypeAny, + { + nodes?: (string | number)[] + prompt_id?: string + timestamp?: number + }, + { + nodes?: (string | number)[] + prompt_id?: string + timestamp?: number + } +> + +declare const zExecutionErrorWsMessage: z.ZodObject< + z.objectUtil.extendShape< + { + prompt_id: z.ZodString + timestamp: z.ZodNumber + }, + { + node_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + node_type: z.ZodString + executed: z.ZodArray, 'many'> + exception_message: z.ZodString + exception_type: z.ZodString + traceback: z.ZodArray + current_inputs: z.ZodAny + current_outputs: z.ZodAny + } + >, + 'strip', + z.ZodTypeAny, + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + exception_message?: string + exception_type?: string + traceback?: string[] + current_inputs?: any + current_outputs?: any + }, + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + exception_message?: string + exception_type?: string + traceback?: string[] + current_inputs?: any + current_outputs?: any + } +> + +declare const zExecutionStartWsMessage: z.ZodObject< + { + prompt_id: z.ZodString + timestamp: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + prompt_id?: string + timestamp?: number + }, + { + prompt_id?: string + timestamp?: number + } +> + +declare const zExecutionSuccessWsMessage: z.ZodObject< + { + prompt_id: z.ZodString + timestamp: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + prompt_id?: string + timestamp?: number + }, + { + prompt_id?: string + timestamp?: number + } +> + +declare const zExtensionsResponse: z.ZodArray + +declare const zHistoryTaskItem: z.ZodObject< + { + taskType: z.ZodLiteral<'History'> + prompt: z.ZodTuple< + [ + z.ZodNumber, + z.ZodString, + z.ZodRecord< + z.ZodString, + z.ZodObject< + { + inputs: z.ZodRecord + class_type: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + inputs?: Record + class_type?: string + }, + { + inputs?: Record + class_type?: string + } + > + >, + z.ZodObject< + { + /** extra_pnginfo can be missing is backend execution gets a validation error. */ + extra_pnginfo: z.ZodOptional< + z.ZodObject< + { + workflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + workflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + workflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + client_id: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + number, + string | number, + number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: number[] | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + }, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + string | number, + string | number, + string | number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: + | z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + } + >, + z.ZodArray, 'many'>, + ], + null + > + status: z.ZodOptional< + z.ZodObject< + { + status_str: z.ZodEnum<['success', 'error']> + completed: z.ZodBoolean + messages: z.ZodArray< + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'execution_start'>, + z.ZodObject< + { + prompt_id: z.ZodString + timestamp: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + prompt_id?: string + timestamp?: number + }, + { + prompt_id?: string + timestamp?: number + } + >, + ], + null + >, + z.ZodTuple< + [ + z.ZodLiteral<'execution_success'>, + z.ZodObject< + { + prompt_id: z.ZodString + timestamp: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + prompt_id?: string + timestamp?: number + }, + { + prompt_id?: string + timestamp?: number + } + >, + ], + null + >, + z.ZodTuple< + [ + z.ZodLiteral<'execution_cached'>, + z.ZodObject< + z.objectUtil.extendShape< + { + prompt_id: z.ZodString + timestamp: z.ZodNumber + }, + { + nodes: z.ZodArray< + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + 'many' + > + } + >, + 'strip', + z.ZodTypeAny, + { + nodes?: (string | number)[] + prompt_id?: string + timestamp?: number + }, + { + nodes?: (string | number)[] + prompt_id?: string + timestamp?: number + } + >, + ], + null + >, + z.ZodTuple< + [ + z.ZodLiteral<'execution_interrupted'>, + z.ZodObject< + z.objectUtil.extendShape< + { + prompt_id: z.ZodString + timestamp: z.ZodNumber + }, + { + node_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + node_type: z.ZodString + executed: z.ZodArray< + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + 'many' + > + } + >, + 'strip', + z.ZodTypeAny, + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + }, + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + } + >, + ], + null + >, + z.ZodTuple< + [ + z.ZodLiteral<'execution_error'>, + z.ZodObject< + z.objectUtil.extendShape< + { + prompt_id: z.ZodString + timestamp: z.ZodNumber + }, + { + node_id: z.ZodUnion<[z.ZodNumber, z.ZodString]> + node_type: z.ZodString + executed: z.ZodArray< + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + 'many' + > + exception_message: z.ZodString + exception_type: z.ZodString + traceback: z.ZodArray + current_inputs: z.ZodAny + current_outputs: z.ZodAny + } + >, + 'strip', + z.ZodTypeAny, + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + exception_message?: string + exception_type?: string + traceback?: string[] + current_inputs?: any + current_outputs?: any + }, + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + exception_message?: string + exception_type?: string + traceback?: string[] + current_inputs?: any + current_outputs?: any + } + >, + ], + null + >, + ] + >, + 'many' + > + }, + 'strip', + z.ZodTypeAny, + { + status_str?: 'success' | 'error' + completed?: boolean + messages?: ( + | [ + 'execution_start', + { + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_success', + { + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_cached', + { + nodes?: (string | number)[] + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_interrupted', + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + }, + ...unknown[], + ] + | [ + 'execution_error', + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + exception_message?: string + exception_type?: string + traceback?: string[] + current_inputs?: any + current_outputs?: any + }, + ...unknown[], + ] + )[] + }, + { + status_str?: 'success' | 'error' + completed?: boolean + messages?: ( + | [ + 'execution_start', + { + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_success', + { + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_cached', + { + nodes?: (string | number)[] + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_interrupted', + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + }, + ...unknown[], + ] + | [ + 'execution_error', + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + exception_message?: string + exception_type?: string + traceback?: string[] + current_inputs?: any + current_outputs?: any + }, + ...unknown[], + ] + )[] + } + > + > + outputs: z.ZodRecord< + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodObject< + { + audio: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + images: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + animated: z.ZodOptional> + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + audio: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + images: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + animated: z.ZodOptional> + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + audio: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + images: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + animated: z.ZodOptional> + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + }, + 'strip', + z.ZodTypeAny, + { + status?: { + status_str?: 'success' | 'error' + completed?: boolean + messages?: ( + | [ + 'execution_start', + { + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_success', + { + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_cached', + { + nodes?: (string | number)[] + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_interrupted', + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + }, + ...unknown[], + ] + | [ + 'execution_error', + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + exception_message?: string + exception_type?: string + traceback?: string[] + current_inputs?: any + current_outputs?: any + }, + ...unknown[], + ] + )[] + } + outputs?: Record< + string | number, + z.objectOutputType< + { + audio: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + images: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + animated: z.ZodOptional> + }, + z.ZodTypeAny, + 'passthrough' + > + > + taskType?: 'History' + prompt?: [ + number, + string, + Record< + string, + { + inputs?: Record + class_type?: string + } + >, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + number, + string | number, + number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: number[] | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + }, + (string | number)[], + ...unknown[], + ] + }, + { + status?: { + status_str?: 'success' | 'error' + completed?: boolean + messages?: ( + | [ + 'execution_start', + { + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_success', + { + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_cached', + { + nodes?: (string | number)[] + prompt_id?: string + timestamp?: number + }, + ...unknown[], + ] + | [ + 'execution_interrupted', + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + }, + ...unknown[], + ] + | [ + 'execution_error', + { + prompt_id?: string + timestamp?: number + node_id?: string | number + node_type?: string + executed?: (string | number)[] + exception_message?: string + exception_type?: string + traceback?: string[] + current_inputs?: any + current_outputs?: any + }, + ...unknown[], + ] + )[] + } + outputs?: Record< + string | number, + z.objectInputType< + { + audio: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + images: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + filename: z.ZodOptional + subfolder: z.ZodOptional + type: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + type?: string + filename?: string + subfolder?: string + }, + { + type?: string + filename?: string + subfolder?: string + } + >, + 'many' + > + > + animated: z.ZodOptional> + }, + z.ZodTypeAny, + 'passthrough' + > + > + taskType?: 'History' + prompt?: [ + number, + string, + Record< + string, + { + inputs?: Record + class_type?: string + } + >, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + string | number, + string | number, + string | number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: + | z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + }, + (string | number)[], + ...unknown[], + ] + } +> + +declare const zInputSpec: z.ZodUnion< + [ + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'INT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'INT'>], null>, + ('INT' | {})[], + ['INT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'INT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'FLOAT'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + min: z.ZodOptional + max: z.ZodOptional + step: z.ZodOptional + round: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodLiteral]> + > + default: z.ZodOptional< + z.ZodUnion<[z.ZodNumber, z.ZodArray]> + > + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'FLOAT'>], null>, + ('FLOAT' | {})[], + ['FLOAT', ...unknown[]] + >, + ...z.ZodEffects, any[], 'FLOAT'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'BOOLEAN'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + label_on: z.ZodOptional + label_off: z.ZodOptional + default: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'BOOLEAN'>], null>, + ('BOOLEAN' | {})[], + ['BOOLEAN', ...unknown[]] + >, + ...z.ZodEffects, any[], 'BOOLEAN'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodLiteral<'STRING'>, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + default: z.ZodOptional + multiline: z.ZodOptional + dynamicPrompts: z.ZodOptional + defaultVal: z.ZodOptional + placeholder: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodLiteral<'STRING'>], null>, + ('STRING' | {})[], + ['STRING', ...unknown[]] + >, + ...z.ZodEffects, any[], 'STRING'>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodArray, + z.ZodObject< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + z.objectUtil.extendShape< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + { + control_after_generate: z.ZodOptional + image_upload: z.ZodOptional + } + >, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodArray], null>, + (any[] | {})[], + [any[], ...unknown[]] + >, + ...z.ZodEffects, any[], any[]>[], + ] + >, + z.ZodUnion< + [ + z.ZodTuple< + [ + z.ZodEffects, + z.ZodObject< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + default: z.ZodOptional + defaultInput: z.ZodOptional + forceInput: z.ZodOptional + lazy: z.ZodOptional + rawLink: z.ZodOptional + tooltip: z.ZodOptional + hidden: z.ZodOptional + advanced: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + ], + null + >, + z.ZodEffects< + z.ZodTuple<[z.ZodEffects], null>, + (string | {})[], + [string, ...unknown[]] + >, + ...z.ZodEffects< + z.ZodEffects, + any[], + string + >[], + ] + >, + ] +> + +declare const zKeybinding: z.ZodObject< + { + commandId: z.ZodString + combo: z.ZodObject< + { + key: z.ZodString + ctrl: z.ZodOptional + alt: z.ZodOptional + shift: z.ZodOptional + meta: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + }, + { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + > + targetSelector: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + }, + { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + } +> + +declare const zLogRawResponse: z.ZodObject< + { + size: z.ZodObject< + { + cols: z.ZodNumber + row: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + cols?: number + row?: number + }, + { + cols?: number + row?: number + } + > + entries: z.ZodArray< + z.ZodObject< + { + t: z.ZodString + m: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + t?: string + m?: string + }, + { + t?: string + m?: string + } + >, + 'many' + > + }, + 'strip', + z.ZodTypeAny, + { + entries?: { + t?: string + m?: string + }[] + size?: { + cols?: number + row?: number + } + }, + { + entries?: { + t?: string + m?: string + }[] + size?: { + cols?: number + row?: number + } + } +> + +declare const zLogsWsMessage: z.ZodObject< + { + size: z.ZodOptional< + z.ZodObject< + { + cols: z.ZodNumber + row: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + cols?: number + row?: number + }, + { + cols?: number + row?: number + } + > + > + entries: z.ZodArray< + z.ZodObject< + { + t: z.ZodString + m: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + t?: string + m?: string + }, + { + t?: string + m?: string + } + >, + 'many' + > + }, + 'strip', + z.ZodTypeAny, + { + entries?: { + t?: string + m?: string + }[] + size?: { + cols?: number + row?: number + } + }, + { + entries?: { + t?: string + m?: string + }[] + size?: { + cols?: number + row?: number + } + } +> + +declare const zNodeId: z.ZodUnion<[z.ZodNumber, z.ZodString]> + +declare const zPendingTaskItem: z.ZodObject< + { + taskType: z.ZodLiteral<'Pending'> + prompt: z.ZodTuple< + [ + z.ZodNumber, + z.ZodString, + z.ZodRecord< + z.ZodString, + z.ZodObject< + { + inputs: z.ZodRecord + class_type: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + inputs?: Record + class_type?: string + }, + { + inputs?: Record + class_type?: string + } + > + >, + z.ZodObject< + { + /** extra_pnginfo can be missing is backend execution gets a validation error. */ + extra_pnginfo: z.ZodOptional< + z.ZodObject< + { + workflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + workflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + workflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + client_id: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + number, + string | number, + number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: number[] | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + }, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + string | number, + string | number, + string | number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: + | z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + } + >, + z.ZodArray, 'many'>, + ], + null + > + }, + 'strip', + z.ZodTypeAny, + { + taskType?: 'Pending' + prompt?: [ + number, + string, + Record< + string, + { + inputs?: Record + class_type?: string + } + >, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + number, + string | number, + number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: number[] | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + }, + (string | number)[], + ...unknown[], + ] + }, + { + taskType?: 'Pending' + prompt?: [ + number, + string, + Record< + string, + { + inputs?: Record + class_type?: string + } + >, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + string | number, + string | number, + string | number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: + | z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + }, + (string | number)[], + ...unknown[], + ] + } +> + +declare const zProgressWsMessage: z.ZodObject< + { + value: z.ZodNumber + max: z.ZodNumber + prompt_id: z.ZodString + node: z.ZodUnion<[z.ZodNumber, z.ZodString]> + }, + 'strip', + z.ZodTypeAny, + { + value?: number + max?: number + prompt_id?: string + node?: string | number + }, + { + value?: number + max?: number + prompt_id?: string + node?: string | number + } +> + +declare const zPromptResponse: z.ZodObject< + { + node_errors: z.ZodOptional> + prompt_id: z.ZodOptional + exec_info: z.ZodOptional< + z.ZodObject< + { + queue_remaining: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + queue_remaining?: number + }, + { + queue_remaining?: number + } + > + > + }, + 'strip', + z.ZodTypeAny, + { + exec_info?: { + queue_remaining?: number + } + prompt_id?: string + node_errors?: string[] + }, + { + exec_info?: { + queue_remaining?: number + } + prompt_id?: string + node_errors?: string[] + } +> + +declare const zRunningTaskItem: z.ZodObject< + { + taskType: z.ZodLiteral<'Running'> + prompt: z.ZodTuple< + [ + z.ZodNumber, + z.ZodString, + z.ZodRecord< + z.ZodString, + z.ZodObject< + { + inputs: z.ZodRecord + class_type: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + inputs?: Record + class_type?: string + }, + { + inputs?: Record + class_type?: string + } + > + >, + z.ZodObject< + { + /** extra_pnginfo can be missing is backend execution gets a validation error. */ + extra_pnginfo: z.ZodOptional< + z.ZodObject< + { + workflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + workflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + workflow: z.ZodObject< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + '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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple< + [z.ZodNumber, z.ZodNumber], + null + >, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + link: z.ZodOptional< + z.ZodNullable + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable< + z.ZodArray + > + > + 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 + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + 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, + number, + string + >, + ] + >, + z.ZodUnion<[z.ZodNumber, z.ZodString]>, + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + >, + z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + >, + ], + null + >, + '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 + font_size: z.ZodOptional + locked: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [ + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + z.ZodNumber, + ], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + config: z.ZodNullable< + z.ZodOptional< + z.ZodObject< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + links_ontop: z.ZodOptional + align_to_grid: z.ZodOptional + }, + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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.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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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[], + 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[], + 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[], + 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 + 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[], + 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 + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + 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 + 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[], + 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 + hash_type: z.ZodOptional + directory: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }, + { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + } + >, + 'many' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + client_id: z.ZodString + }, + 'strip', + z.ZodTypeAny, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + number, + string | number, + number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: number[] | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + }, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + string | number, + string | number, + string | number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: + | z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + } + >, + z.ZodArray, 'many'>, + ], + null + > + remove: z.ZodObject< + { + name: z.ZodLiteral<'Cancel'> + cb: z.ZodFunction, z.ZodUnknown> + }, + 'strip', + z.ZodTypeAny, + { + name?: 'Cancel' + cb?: (...args: unknown[]) => unknown + }, + { + name?: 'Cancel' + cb?: (...args: unknown[]) => unknown + } + > + }, + 'strip', + z.ZodTypeAny, + { + taskType?: 'Running' + prompt?: [ + number, + string, + Record< + string, + { + inputs?: Record + class_type?: string + } + >, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + number, + string | number, + number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectOutputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: number[] | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectOutputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + }, + (string | number)[], + ...unknown[], + ] + remove?: { + name?: 'Cancel' + cb?: (...args: unknown[]) => unknown + } + }, + { + taskType?: 'Running' + prompt?: [ + number, + string, + Record< + string, + { + inputs?: Record + class_type?: string + } + >, + { + extra_pnginfo?: { + workflow?: { + links?: [ + number, + string | number, + string | number, + string | number, + string | number, + string | number | string[], + ...unknown[], + ][] + version?: number + last_node_id?: string | number + last_link_id?: number + nodes?: 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[], + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + flags: z.ZodObject< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + collapsed: z.ZodOptional + pinned: z.ZodOptional + allow_interaction: z.ZodOptional + horizontal: z.ZodOptional + skip_repeated_outputs: z.ZodOptional + }, + 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.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + link: z.ZodOptional> + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + outputs: z.ZodOptional< + z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + name: z.ZodString + type: z.ZodUnion< + [ + z.ZodString, + z.ZodArray, + z.ZodNumber, + ] + > + links: z.ZodOptional< + z.ZodNullable> + > + slot_index: z.ZodOptional< + z.ZodUnion< + [ + z.ZodNumber, + z.ZodEffects< + z.ZodEffects, + number, + string + >, + ] + > + > + }, + z.ZodTypeAny, + 'passthrough' + > + >, + 'many' + > + > + properties: z.ZodObject< + { + 'Node name for S&R': z.ZodOptional + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + 'Node name for S&R': z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + > + > + widgets_values: z.ZodOptional< + z.ZodUnion< + [ + z.ZodArray, + z.ZodRecord, + ] + > + > + color: z.ZodOptional + bgcolor: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + groups?: z.objectInputType< + { + title: z.ZodString + bounding: z.ZodTuple< + [z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], + null + > + color: z.ZodOptional + font_size: z.ZodOptional + locked: z.ZodOptional + }, + z.ZodTypeAny, + 'passthrough' + >[] + config?: { + links_ontop?: boolean + align_to_grid?: boolean + } & { + [k: string]: unknown + } + extra?: { + ds?: { + scale?: number + offset?: + | z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + | [number, number, ...unknown[]] + } & { + [k: string]: unknown + } + info?: { + name?: string + author?: string + description?: string + version?: string + created?: string + modified?: string + software?: string + } & { + [k: string]: unknown + } + linkExtensions?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + >[] + reroutes?: z.objectInputType< + { + id: z.ZodNumber + parentId: z.ZodOptional + 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[], + z.objectInputType< + { + 0: z.ZodNumber + 1: z.ZodNumber + }, + z.ZodTypeAny, + 'passthrough' + > + >, + z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, + ] + > + linkIds: z.ZodOptional< + z.ZodNullable> + > + }, + z.ZodTypeAny, + 'passthrough' + >[] + } & { + [k: string]: unknown + } + models?: { + name?: string + url?: string + hash?: string + hash_type?: string + directory?: string + }[] + } & { + [k: string]: unknown + } + } & { + [k: string]: unknown + } + client_id?: string + }, + (string | number)[], + ...unknown[], + ] + remove?: { + name?: 'Cancel' + cb?: (...args: unknown[]) => unknown + } + } +> + +declare const zSettings: z.ZodIntersection< + z.ZodRecord, + z.ZodOptional< + z.ZodObject< + { + 'Comfy.ColorPalette': z.ZodString + 'Comfy.CustomColorPalettes': z.ZodRecord< + z.ZodString, + z.ZodObject< + { + id: z.ZodString + name: z.ZodString + colors: z.ZodObject< + { + node_slot: z.ZodObject< + { + CLIP: z.ZodOptional + CLIP_VISION: z.ZodOptional + CLIP_VISION_OUTPUT: z.ZodOptional + CONDITIONING: z.ZodOptional + CONTROL_NET: z.ZodOptional + IMAGE: z.ZodOptional + LATENT: z.ZodOptional + MASK: z.ZodOptional + MODEL: z.ZodOptional + STYLE_MODEL: z.ZodOptional + VAE: z.ZodOptional + NOISE: z.ZodOptional + GUIDER: z.ZodOptional + SAMPLER: z.ZodOptional + SIGMAS: z.ZodOptional + TAESD: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + }, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + > + litegraph_base: z.ZodObject< + { + BACKGROUND_IMAGE: z.ZodOptional + CLEAR_BACKGROUND_COLOR: z.ZodOptional + NODE_TITLE_COLOR: z.ZodOptional + NODE_SELECTED_TITLE_COLOR: z.ZodOptional + NODE_TEXT_SIZE: z.ZodOptional + NODE_TEXT_COLOR: z.ZodOptional + NODE_SUBTEXT_SIZE: z.ZodOptional + NODE_DEFAULT_COLOR: z.ZodOptional + NODE_DEFAULT_BGCOLOR: z.ZodOptional + NODE_DEFAULT_BOXCOLOR: z.ZodOptional + NODE_DEFAULT_SHAPE: z.ZodOptional< + z.ZodUnion< + [ + z.ZodLiteral, + z.ZodLiteral, + z.ZodLiteral, + z.ZodString, + ] + > + > + NODE_BOX_OUTLINE_COLOR: z.ZodOptional + NODE_BYPASS_BGCOLOR: z.ZodOptional + NODE_ERROR_COLOUR: z.ZodOptional + DEFAULT_SHADOW_COLOR: z.ZodOptional + DEFAULT_GROUP_FONT: z.ZodOptional + WIDGET_BGCOLOR: z.ZodOptional + WIDGET_OUTLINE_COLOR: z.ZodOptional + WIDGET_TEXT_COLOR: z.ZodOptional + WIDGET_SECONDARY_TEXT_COLOR: z.ZodOptional + LINK_COLOR: z.ZodOptional + EVENT_LINK_COLOR: z.ZodOptional + CONNECTING_LINK_COLOR: z.ZodOptional + BADGE_FG_COLOR: z.ZodOptional + BADGE_BG_COLOR: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + }, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + > + comfy_base: z.ZodObject< + { + 'fg-color': z.ZodOptional + 'bg-color': z.ZodOptional + 'bg-img': z.ZodOptional> + 'comfy-menu-bg': z.ZodOptional + 'comfy-menu-secondary-bg': z.ZodOptional + 'comfy-input-bg': z.ZodOptional + 'input-text': z.ZodOptional + 'descrip-text': z.ZodOptional + 'drag-text': z.ZodOptional + 'error-text': z.ZodOptional + 'border-color': z.ZodOptional + 'tr-even-bg-color': z.ZodOptional + 'tr-odd-bg-color': z.ZodOptional + 'content-bg': z.ZodOptional + 'content-fg': z.ZodOptional + 'content-hover-bg': z.ZodOptional + 'content-hover-fg': z.ZodOptional + 'bar-shadow': z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + }, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + > + }, + 'strip', + z.ZodTypeAny, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + }, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + } + > + }, + 'passthrough', + z.ZodTypeAny, + z.objectOutputType< + { + id: z.ZodString + name: z.ZodString + colors: z.ZodObject< + { + node_slot: z.ZodObject< + { + CLIP: z.ZodOptional + CLIP_VISION: z.ZodOptional + CLIP_VISION_OUTPUT: z.ZodOptional + CONDITIONING: z.ZodOptional + CONTROL_NET: z.ZodOptional + IMAGE: z.ZodOptional + LATENT: z.ZodOptional + MASK: z.ZodOptional + MODEL: z.ZodOptional + STYLE_MODEL: z.ZodOptional + VAE: z.ZodOptional + NOISE: z.ZodOptional + GUIDER: z.ZodOptional + SAMPLER: z.ZodOptional + SIGMAS: z.ZodOptional + TAESD: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + }, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + > + litegraph_base: z.ZodObject< + { + BACKGROUND_IMAGE: z.ZodOptional + CLEAR_BACKGROUND_COLOR: z.ZodOptional + NODE_TITLE_COLOR: z.ZodOptional + NODE_SELECTED_TITLE_COLOR: z.ZodOptional + NODE_TEXT_SIZE: z.ZodOptional + NODE_TEXT_COLOR: z.ZodOptional + NODE_SUBTEXT_SIZE: z.ZodOptional + NODE_DEFAULT_COLOR: z.ZodOptional + NODE_DEFAULT_BGCOLOR: z.ZodOptional + NODE_DEFAULT_BOXCOLOR: z.ZodOptional + NODE_DEFAULT_SHAPE: z.ZodOptional< + z.ZodUnion< + [ + z.ZodLiteral, + z.ZodLiteral, + z.ZodLiteral, + z.ZodString, + ] + > + > + NODE_BOX_OUTLINE_COLOR: z.ZodOptional + NODE_BYPASS_BGCOLOR: z.ZodOptional + NODE_ERROR_COLOUR: z.ZodOptional + DEFAULT_SHADOW_COLOR: z.ZodOptional + DEFAULT_GROUP_FONT: z.ZodOptional + WIDGET_BGCOLOR: z.ZodOptional + WIDGET_OUTLINE_COLOR: z.ZodOptional + WIDGET_TEXT_COLOR: z.ZodOptional + WIDGET_SECONDARY_TEXT_COLOR: z.ZodOptional + LINK_COLOR: z.ZodOptional + EVENT_LINK_COLOR: z.ZodOptional + CONNECTING_LINK_COLOR: z.ZodOptional + BADGE_FG_COLOR: z.ZodOptional + BADGE_BG_COLOR: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + }, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + > + comfy_base: z.ZodObject< + { + 'fg-color': z.ZodOptional + 'bg-color': z.ZodOptional + 'bg-img': z.ZodOptional> + 'comfy-menu-bg': z.ZodOptional + 'comfy-menu-secondary-bg': z.ZodOptional + 'comfy-input-bg': z.ZodOptional + 'input-text': z.ZodOptional + 'descrip-text': z.ZodOptional + 'drag-text': z.ZodOptional + 'error-text': z.ZodOptional + 'border-color': z.ZodOptional + 'tr-even-bg-color': z.ZodOptional + 'tr-odd-bg-color': z.ZodOptional + 'content-bg': z.ZodOptional + 'content-fg': z.ZodOptional + 'content-hover-bg': z.ZodOptional + 'content-hover-fg': z.ZodOptional + 'bar-shadow': z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + }, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + > + }, + 'strip', + z.ZodTypeAny, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + }, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + } + > + }, + z.ZodTypeAny, + 'passthrough' + >, + z.objectInputType< + { + id: z.ZodString + name: z.ZodString + colors: z.ZodObject< + { + node_slot: z.ZodObject< + { + CLIP: z.ZodOptional + CLIP_VISION: z.ZodOptional + CLIP_VISION_OUTPUT: z.ZodOptional + CONDITIONING: z.ZodOptional + CONTROL_NET: z.ZodOptional + IMAGE: z.ZodOptional + LATENT: z.ZodOptional + MASK: z.ZodOptional + MODEL: z.ZodOptional + STYLE_MODEL: z.ZodOptional + VAE: z.ZodOptional + NOISE: z.ZodOptional + GUIDER: z.ZodOptional + SAMPLER: z.ZodOptional + SIGMAS: z.ZodOptional + TAESD: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + }, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + > + litegraph_base: z.ZodObject< + { + BACKGROUND_IMAGE: z.ZodOptional + CLEAR_BACKGROUND_COLOR: z.ZodOptional + NODE_TITLE_COLOR: z.ZodOptional + NODE_SELECTED_TITLE_COLOR: z.ZodOptional + NODE_TEXT_SIZE: z.ZodOptional + NODE_TEXT_COLOR: z.ZodOptional + NODE_SUBTEXT_SIZE: z.ZodOptional + NODE_DEFAULT_COLOR: z.ZodOptional + NODE_DEFAULT_BGCOLOR: z.ZodOptional + NODE_DEFAULT_BOXCOLOR: z.ZodOptional + NODE_DEFAULT_SHAPE: z.ZodOptional< + z.ZodUnion< + [ + z.ZodLiteral, + z.ZodLiteral, + z.ZodLiteral, + z.ZodString, + ] + > + > + NODE_BOX_OUTLINE_COLOR: z.ZodOptional + NODE_BYPASS_BGCOLOR: z.ZodOptional + NODE_ERROR_COLOUR: z.ZodOptional + DEFAULT_SHADOW_COLOR: z.ZodOptional + DEFAULT_GROUP_FONT: z.ZodOptional + WIDGET_BGCOLOR: z.ZodOptional + WIDGET_OUTLINE_COLOR: z.ZodOptional + WIDGET_TEXT_COLOR: z.ZodOptional + WIDGET_SECONDARY_TEXT_COLOR: z.ZodOptional + LINK_COLOR: z.ZodOptional + EVENT_LINK_COLOR: z.ZodOptional + CONNECTING_LINK_COLOR: z.ZodOptional + BADGE_FG_COLOR: z.ZodOptional + BADGE_BG_COLOR: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + }, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + > + comfy_base: z.ZodObject< + { + 'fg-color': z.ZodOptional + 'bg-color': z.ZodOptional + 'bg-img': z.ZodOptional> + 'comfy-menu-bg': z.ZodOptional + 'comfy-menu-secondary-bg': z.ZodOptional + 'comfy-input-bg': z.ZodOptional + 'input-text': z.ZodOptional + 'descrip-text': z.ZodOptional + 'drag-text': z.ZodOptional + 'error-text': z.ZodOptional + 'border-color': z.ZodOptional + 'tr-even-bg-color': z.ZodOptional + 'tr-odd-bg-color': z.ZodOptional + 'content-bg': z.ZodOptional + 'content-fg': z.ZodOptional + 'content-hover-bg': z.ZodOptional + 'content-hover-fg': z.ZodOptional + 'bar-shadow': z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + }, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + > + }, + 'strip', + z.ZodTypeAny, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + }, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + } + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + > + 'Comfy.ConfirmClear': z.ZodBoolean + 'Comfy.DevMode': z.ZodBoolean + 'Comfy.Workflow.ShowMissingNodesWarning': z.ZodBoolean + 'Comfy.Workflow.ShowMissingModelsWarning': z.ZodBoolean + 'Comfy.DisableFloatRounding': z.ZodBoolean + 'Comfy.DisableSliders': z.ZodBoolean + 'Comfy.DOMClippingEnabled': z.ZodBoolean + 'Comfy.EditAttention.Delta': z.ZodNumber + 'Comfy.EnableTooltips': z.ZodBoolean + 'Comfy.EnableWorkflowViewRestore': z.ZodBoolean + 'Comfy.FloatRoundingPrecision': z.ZodNumber + 'Comfy.Graph.CanvasInfo': z.ZodBoolean + 'Comfy.Graph.ZoomSpeed': z.ZodNumber + 'Comfy.Group.DoubleClickTitleToEdit': z.ZodBoolean + 'Comfy.GroupSelectedNodes.Padding': z.ZodNumber + 'Comfy.InvertMenuScrolling': z.ZodBoolean + 'Comfy.Locale': z.ZodString + 'Comfy.Logging.Enabled': z.ZodBoolean + 'Comfy.NodeLibrary.Bookmarks': z.ZodArray + 'Comfy.NodeLibrary.Bookmarks.V2': z.ZodArray + 'Comfy.NodeLibrary.BookmarksCustomization': z.ZodRecord< + z.ZodString, + z.ZodObject< + { + icon: z.ZodOptional + color: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + color?: string + icon?: string + }, + { + color?: string + icon?: string + } + > + > + 'Comfy.NodeInputConversionSubmenus': z.ZodBoolean + 'Comfy.LinkRelease.Action': z.ZodEnum<[string, ...string[]]> + 'Comfy.LinkRelease.ActionShift': z.ZodEnum<[string, ...string[]]> + 'Comfy.NodeSearchBoxImpl.NodePreview': z.ZodBoolean + 'Comfy.NodeSearchBoxImpl': z.ZodEnum<['default', 'simple']> + 'Comfy.NodeSearchBoxImpl.ShowCategory': z.ZodBoolean + 'Comfy.NodeSearchBoxImpl.ShowIdName': z.ZodBoolean + 'Comfy.NodeSuggestions.number': z.ZodNumber + 'Comfy.Node.ShowDeprecated': z.ZodBoolean + 'Comfy.Node.ShowExperimental': z.ZodBoolean + 'Comfy.PreviewFormat': z.ZodString + 'Comfy.PromptFilename': z.ZodBoolean + 'Comfy.Sidebar.Location': z.ZodEnum<['left', 'right']> + 'Comfy.Sidebar.Size': z.ZodEnum<['small', 'normal']> + 'Comfy.SwitchUser': z.ZodAny + 'Comfy.SnapToGrid.GridSize': z.ZodNumber + 'Comfy.TextareaWidget.FontSize': z.ZodNumber + 'Comfy.TextareaWidget.Spellcheck': z.ZodBoolean + 'Comfy.UseNewMenu': z.ZodEnum<['Disabled', 'Top', 'Bottom']> + 'Comfy.TreeExplorer.ItemPadding': z.ZodNumber + 'Comfy.Validation.Workflows': z.ZodBoolean + 'Comfy.Workflow.SortNodeIdOnSave': z.ZodBoolean + 'Comfy.Queue.ImageFit': z.ZodEnum<['contain', 'cover']> + 'Comfy.Workflow.WorkflowTabsPosition': z.ZodEnum<['Sidebar', 'Topbar']> + 'Comfy.Node.DoubleClickTitleToEdit': z.ZodBoolean + 'Comfy.Window.UnloadConfirmation': z.ZodBoolean + 'Comfy.NodeBadge.NodeSourceBadgeMode': z.ZodEnum<[string, ...string[]]> + 'Comfy.NodeBadge.NodeIdBadgeMode': z.ZodEnum<[string, ...string[]]> + 'Comfy.NodeBadge.NodeLifeCycleBadgeMode': z.ZodEnum< + [string, ...string[]] + > + 'Comfy.QueueButton.BatchCountLimit': z.ZodNumber + 'Comfy.Keybinding.UnsetBindings': z.ZodArray< + z.ZodObject< + { + commandId: z.ZodString + combo: z.ZodObject< + { + key: z.ZodString + ctrl: z.ZodOptional + alt: z.ZodOptional + shift: z.ZodOptional + meta: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + }, + { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + > + targetSelector: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + }, + { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + } + >, + 'many' + > + 'Comfy.Keybinding.NewBindings': z.ZodArray< + z.ZodObject< + { + commandId: z.ZodString + combo: z.ZodObject< + { + key: z.ZodString + ctrl: z.ZodOptional + alt: z.ZodOptional + shift: z.ZodOptional + meta: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + }, + { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + > + targetSelector: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + }, + { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + } + >, + 'many' + > + 'Comfy.Extension.Disabled': z.ZodArray + 'Comfy.Settings.ExtensionPanel': z.ZodBoolean + 'Comfy.LinkRenderMode': z.ZodNumber + 'Comfy.Node.AutoSnapLinkToSlot': z.ZodBoolean + 'Comfy.Node.SnapHighlightsNode': z.ZodBoolean + 'Comfy.Server.ServerConfigValues': z.ZodRecord + 'Comfy.Server.LaunchArgs': z.ZodRecord + 'LiteGraph.Canvas.MaximumFps': z.ZodNumber + 'Comfy.Workflow.ConfirmDelete': z.ZodBoolean + }, + 'strip', + z.ZodTypeAny, + { + 'Comfy.ColorPalette'?: string + 'Comfy.CustomColorPalettes'?: Record< + string, + z.objectOutputType< + { + id: z.ZodString + name: z.ZodString + colors: z.ZodObject< + { + node_slot: z.ZodObject< + { + CLIP: z.ZodOptional + CLIP_VISION: z.ZodOptional + CLIP_VISION_OUTPUT: z.ZodOptional + CONDITIONING: z.ZodOptional + CONTROL_NET: z.ZodOptional + IMAGE: z.ZodOptional + LATENT: z.ZodOptional + MASK: z.ZodOptional + MODEL: z.ZodOptional + STYLE_MODEL: z.ZodOptional + VAE: z.ZodOptional + NOISE: z.ZodOptional + GUIDER: z.ZodOptional + SAMPLER: z.ZodOptional + SIGMAS: z.ZodOptional + TAESD: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + }, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + > + litegraph_base: z.ZodObject< + { + BACKGROUND_IMAGE: z.ZodOptional + CLEAR_BACKGROUND_COLOR: z.ZodOptional + NODE_TITLE_COLOR: z.ZodOptional + NODE_SELECTED_TITLE_COLOR: z.ZodOptional + NODE_TEXT_SIZE: z.ZodOptional + NODE_TEXT_COLOR: z.ZodOptional + NODE_SUBTEXT_SIZE: z.ZodOptional + NODE_DEFAULT_COLOR: z.ZodOptional + NODE_DEFAULT_BGCOLOR: z.ZodOptional + NODE_DEFAULT_BOXCOLOR: z.ZodOptional + NODE_DEFAULT_SHAPE: z.ZodOptional< + z.ZodUnion< + [ + z.ZodLiteral, + z.ZodLiteral, + z.ZodLiteral, + z.ZodString, + ] + > + > + NODE_BOX_OUTLINE_COLOR: z.ZodOptional + NODE_BYPASS_BGCOLOR: z.ZodOptional + NODE_ERROR_COLOUR: z.ZodOptional + DEFAULT_SHADOW_COLOR: z.ZodOptional + DEFAULT_GROUP_FONT: z.ZodOptional + WIDGET_BGCOLOR: z.ZodOptional + WIDGET_OUTLINE_COLOR: z.ZodOptional + WIDGET_TEXT_COLOR: z.ZodOptional + WIDGET_SECONDARY_TEXT_COLOR: z.ZodOptional + LINK_COLOR: z.ZodOptional + EVENT_LINK_COLOR: z.ZodOptional + CONNECTING_LINK_COLOR: z.ZodOptional + BADGE_FG_COLOR: z.ZodOptional + BADGE_BG_COLOR: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + }, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + > + comfy_base: z.ZodObject< + { + 'fg-color': z.ZodOptional + 'bg-color': z.ZodOptional + 'bg-img': z.ZodOptional> + 'comfy-menu-bg': z.ZodOptional + 'comfy-menu-secondary-bg': z.ZodOptional + 'comfy-input-bg': z.ZodOptional + 'input-text': z.ZodOptional + 'descrip-text': z.ZodOptional + 'drag-text': z.ZodOptional + 'error-text': z.ZodOptional + 'border-color': z.ZodOptional + 'tr-even-bg-color': z.ZodOptional + 'tr-odd-bg-color': z.ZodOptional + 'content-bg': z.ZodOptional + 'content-fg': z.ZodOptional + 'content-hover-bg': z.ZodOptional + 'content-hover-fg': z.ZodOptional + 'bar-shadow': z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + }, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + > + }, + 'strip', + z.ZodTypeAny, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + }, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + } + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + 'Comfy.ConfirmClear'?: boolean + 'Comfy.DevMode'?: boolean + 'Comfy.Workflow.ShowMissingNodesWarning'?: boolean + 'Comfy.Workflow.ShowMissingModelsWarning'?: boolean + 'Comfy.DisableFloatRounding'?: boolean + 'Comfy.DisableSliders'?: boolean + 'Comfy.DOMClippingEnabled'?: boolean + 'Comfy.EditAttention.Delta'?: number + 'Comfy.EnableTooltips'?: boolean + 'Comfy.EnableWorkflowViewRestore'?: boolean + 'Comfy.FloatRoundingPrecision'?: number + 'Comfy.Graph.CanvasInfo'?: boolean + 'Comfy.Graph.ZoomSpeed'?: number + 'Comfy.Group.DoubleClickTitleToEdit'?: boolean + 'Comfy.GroupSelectedNodes.Padding'?: number + 'Comfy.InvertMenuScrolling'?: boolean + 'Comfy.Locale'?: string + 'Comfy.Logging.Enabled'?: boolean + 'Comfy.NodeLibrary.Bookmarks'?: string[] + 'Comfy.NodeLibrary.Bookmarks.V2'?: string[] + 'Comfy.NodeLibrary.BookmarksCustomization'?: Record< + string, + { + color?: string + icon?: string + } + > + 'Comfy.NodeInputConversionSubmenus'?: boolean + 'Comfy.LinkRelease.Action'?: string + 'Comfy.LinkRelease.ActionShift'?: string + 'Comfy.NodeSearchBoxImpl.NodePreview'?: boolean + 'Comfy.NodeSearchBoxImpl'?: 'default' | 'simple' + 'Comfy.NodeSearchBoxImpl.ShowCategory'?: boolean + 'Comfy.NodeSearchBoxImpl.ShowIdName'?: boolean + 'Comfy.NodeSuggestions.number'?: number + 'Comfy.Node.ShowDeprecated'?: boolean + 'Comfy.Node.ShowExperimental'?: boolean + 'Comfy.PreviewFormat'?: string + 'Comfy.PromptFilename'?: boolean + 'Comfy.Sidebar.Location'?: 'left' | 'right' + 'Comfy.Sidebar.Size'?: 'small' | 'normal' + 'Comfy.SwitchUser'?: any + 'Comfy.SnapToGrid.GridSize'?: number + 'Comfy.TextareaWidget.FontSize'?: number + 'Comfy.TextareaWidget.Spellcheck'?: boolean + 'Comfy.UseNewMenu'?: 'Disabled' | 'Top' | 'Bottom' + 'Comfy.TreeExplorer.ItemPadding'?: number + 'Comfy.Validation.Workflows'?: boolean + 'Comfy.Workflow.SortNodeIdOnSave'?: boolean + 'Comfy.Queue.ImageFit'?: 'contain' | 'cover' + 'Comfy.Workflow.WorkflowTabsPosition'?: 'Sidebar' | 'Topbar' + 'Comfy.Node.DoubleClickTitleToEdit'?: boolean + 'Comfy.Window.UnloadConfirmation'?: boolean + 'Comfy.NodeBadge.NodeSourceBadgeMode'?: string + 'Comfy.NodeBadge.NodeIdBadgeMode'?: string + 'Comfy.NodeBadge.NodeLifeCycleBadgeMode'?: string + 'Comfy.QueueButton.BatchCountLimit'?: number + 'Comfy.Keybinding.UnsetBindings'?: { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + }[] + 'Comfy.Keybinding.NewBindings'?: { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + }[] + 'Comfy.Extension.Disabled'?: string[] + 'Comfy.Settings.ExtensionPanel'?: boolean + 'Comfy.LinkRenderMode'?: number + 'Comfy.Node.AutoSnapLinkToSlot'?: boolean + 'Comfy.Node.SnapHighlightsNode'?: boolean + 'Comfy.Server.ServerConfigValues'?: Record + 'Comfy.Server.LaunchArgs'?: Record + 'LiteGraph.Canvas.MaximumFps'?: number + 'Comfy.Workflow.ConfirmDelete'?: boolean + }, + { + 'Comfy.ColorPalette'?: string + 'Comfy.CustomColorPalettes'?: Record< + string, + z.objectInputType< + { + id: z.ZodString + name: z.ZodString + colors: z.ZodObject< + { + node_slot: z.ZodObject< + { + CLIP: z.ZodOptional + CLIP_VISION: z.ZodOptional + CLIP_VISION_OUTPUT: z.ZodOptional + CONDITIONING: z.ZodOptional + CONTROL_NET: z.ZodOptional + IMAGE: z.ZodOptional + LATENT: z.ZodOptional + MASK: z.ZodOptional + MODEL: z.ZodOptional + STYLE_MODEL: z.ZodOptional + VAE: z.ZodOptional + NOISE: z.ZodOptional + GUIDER: z.ZodOptional + SAMPLER: z.ZodOptional + SIGMAS: z.ZodOptional + TAESD: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + }, + { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + > + litegraph_base: z.ZodObject< + { + BACKGROUND_IMAGE: z.ZodOptional + CLEAR_BACKGROUND_COLOR: z.ZodOptional + NODE_TITLE_COLOR: z.ZodOptional + NODE_SELECTED_TITLE_COLOR: z.ZodOptional + NODE_TEXT_SIZE: z.ZodOptional + NODE_TEXT_COLOR: z.ZodOptional + NODE_SUBTEXT_SIZE: z.ZodOptional + NODE_DEFAULT_COLOR: z.ZodOptional + NODE_DEFAULT_BGCOLOR: z.ZodOptional + NODE_DEFAULT_BOXCOLOR: z.ZodOptional + NODE_DEFAULT_SHAPE: z.ZodOptional< + z.ZodUnion< + [ + z.ZodLiteral, + z.ZodLiteral, + z.ZodLiteral, + z.ZodString, + ] + > + > + NODE_BOX_OUTLINE_COLOR: z.ZodOptional + NODE_BYPASS_BGCOLOR: z.ZodOptional + NODE_ERROR_COLOUR: z.ZodOptional + DEFAULT_SHADOW_COLOR: z.ZodOptional + DEFAULT_GROUP_FONT: z.ZodOptional + WIDGET_BGCOLOR: z.ZodOptional + WIDGET_OUTLINE_COLOR: z.ZodOptional + WIDGET_TEXT_COLOR: z.ZodOptional + WIDGET_SECONDARY_TEXT_COLOR: z.ZodOptional + LINK_COLOR: z.ZodOptional + EVENT_LINK_COLOR: z.ZodOptional + CONNECTING_LINK_COLOR: z.ZodOptional + BADGE_FG_COLOR: z.ZodOptional + BADGE_BG_COLOR: z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + }, + { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + > + comfy_base: z.ZodObject< + { + 'fg-color': z.ZodOptional + 'bg-color': z.ZodOptional + 'bg-img': z.ZodOptional> + 'comfy-menu-bg': z.ZodOptional + 'comfy-menu-secondary-bg': z.ZodOptional + 'comfy-input-bg': z.ZodOptional + 'input-text': z.ZodOptional + 'descrip-text': z.ZodOptional + 'drag-text': z.ZodOptional + 'error-text': z.ZodOptional + 'border-color': z.ZodOptional + 'tr-even-bg-color': z.ZodOptional + 'tr-odd-bg-color': z.ZodOptional + 'content-bg': z.ZodOptional + 'content-fg': z.ZodOptional + 'content-hover-bg': z.ZodOptional + 'content-hover-fg': z.ZodOptional + 'bar-shadow': z.ZodOptional + }, + 'strip', + z.ZodTypeAny, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + }, + { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + > + }, + 'strip', + z.ZodTypeAny, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + }, + { + node_slot?: { + CLIP?: string + CLIP_VISION?: string + CLIP_VISION_OUTPUT?: string + CONDITIONING?: string + CONTROL_NET?: string + IMAGE?: string + LATENT?: string + MASK?: string + MODEL?: string + STYLE_MODEL?: string + VAE?: string + NOISE?: string + GUIDER?: string + SAMPLER?: string + SIGMAS?: string + TAESD?: string + } + litegraph_base?: { + BACKGROUND_IMAGE?: string + CLEAR_BACKGROUND_COLOR?: string + NODE_TITLE_COLOR?: string + NODE_SELECTED_TITLE_COLOR?: string + NODE_TEXT_SIZE?: number + NODE_TEXT_COLOR?: string + NODE_SUBTEXT_SIZE?: number + NODE_DEFAULT_COLOR?: string + NODE_DEFAULT_BGCOLOR?: string + NODE_DEFAULT_BOXCOLOR?: string + NODE_DEFAULT_SHAPE?: string | RenderShape + NODE_BOX_OUTLINE_COLOR?: string + NODE_BYPASS_BGCOLOR?: string + NODE_ERROR_COLOUR?: string + DEFAULT_SHADOW_COLOR?: string + DEFAULT_GROUP_FONT?: number + WIDGET_BGCOLOR?: string + WIDGET_OUTLINE_COLOR?: string + WIDGET_TEXT_COLOR?: string + WIDGET_SECONDARY_TEXT_COLOR?: string + LINK_COLOR?: string + EVENT_LINK_COLOR?: string + CONNECTING_LINK_COLOR?: string + BADGE_FG_COLOR?: string + BADGE_BG_COLOR?: string + } + comfy_base?: { + 'fg-color'?: string + 'bg-color'?: string + 'bg-img'?: string + 'comfy-menu-bg'?: string + 'comfy-menu-secondary-bg'?: string + 'comfy-input-bg'?: string + 'input-text'?: string + 'descrip-text'?: string + 'drag-text'?: string + 'error-text'?: string + 'border-color'?: string + 'tr-even-bg-color'?: string + 'tr-odd-bg-color'?: string + 'content-bg'?: string + 'content-fg'?: string + 'content-hover-bg'?: string + 'content-hover-fg'?: string + 'bar-shadow'?: string + } + } + > + }, + z.ZodTypeAny, + 'passthrough' + > + > + 'Comfy.ConfirmClear'?: boolean + 'Comfy.DevMode'?: boolean + 'Comfy.Workflow.ShowMissingNodesWarning'?: boolean + 'Comfy.Workflow.ShowMissingModelsWarning'?: boolean + 'Comfy.DisableFloatRounding'?: boolean + 'Comfy.DisableSliders'?: boolean + 'Comfy.DOMClippingEnabled'?: boolean + 'Comfy.EditAttention.Delta'?: number + 'Comfy.EnableTooltips'?: boolean + 'Comfy.EnableWorkflowViewRestore'?: boolean + 'Comfy.FloatRoundingPrecision'?: number + 'Comfy.Graph.CanvasInfo'?: boolean + 'Comfy.Graph.ZoomSpeed'?: number + 'Comfy.Group.DoubleClickTitleToEdit'?: boolean + 'Comfy.GroupSelectedNodes.Padding'?: number + 'Comfy.InvertMenuScrolling'?: boolean + 'Comfy.Locale'?: string + 'Comfy.Logging.Enabled'?: boolean + 'Comfy.NodeLibrary.Bookmarks'?: string[] + 'Comfy.NodeLibrary.Bookmarks.V2'?: string[] + 'Comfy.NodeLibrary.BookmarksCustomization'?: Record< + string, + { + color?: string + icon?: string + } + > + 'Comfy.NodeInputConversionSubmenus'?: boolean + 'Comfy.LinkRelease.Action'?: string + 'Comfy.LinkRelease.ActionShift'?: string + 'Comfy.NodeSearchBoxImpl.NodePreview'?: boolean + 'Comfy.NodeSearchBoxImpl'?: 'default' | 'simple' + 'Comfy.NodeSearchBoxImpl.ShowCategory'?: boolean + 'Comfy.NodeSearchBoxImpl.ShowIdName'?: boolean + 'Comfy.NodeSuggestions.number'?: number + 'Comfy.Node.ShowDeprecated'?: boolean + 'Comfy.Node.ShowExperimental'?: boolean + 'Comfy.PreviewFormat'?: string + 'Comfy.PromptFilename'?: boolean + 'Comfy.Sidebar.Location'?: 'left' | 'right' + 'Comfy.Sidebar.Size'?: 'small' | 'normal' + 'Comfy.SwitchUser'?: any + 'Comfy.SnapToGrid.GridSize'?: number + 'Comfy.TextareaWidget.FontSize'?: number + 'Comfy.TextareaWidget.Spellcheck'?: boolean + 'Comfy.UseNewMenu'?: 'Disabled' | 'Top' | 'Bottom' + 'Comfy.TreeExplorer.ItemPadding'?: number + 'Comfy.Validation.Workflows'?: boolean + 'Comfy.Workflow.SortNodeIdOnSave'?: boolean + 'Comfy.Queue.ImageFit'?: 'contain' | 'cover' + 'Comfy.Workflow.WorkflowTabsPosition'?: 'Sidebar' | 'Topbar' + 'Comfy.Node.DoubleClickTitleToEdit'?: boolean + 'Comfy.Window.UnloadConfirmation'?: boolean + 'Comfy.NodeBadge.NodeSourceBadgeMode'?: string + 'Comfy.NodeBadge.NodeIdBadgeMode'?: string + 'Comfy.NodeBadge.NodeLifeCycleBadgeMode'?: string + 'Comfy.QueueButton.BatchCountLimit'?: number + 'Comfy.Keybinding.UnsetBindings'?: { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + }[] + 'Comfy.Keybinding.NewBindings'?: { + commandId?: string + combo?: { + shift?: boolean + key?: string + ctrl?: boolean + alt?: boolean + meta?: boolean + } + targetSelector?: string + }[] + 'Comfy.Extension.Disabled'?: string[] + 'Comfy.Settings.ExtensionPanel'?: boolean + 'Comfy.LinkRenderMode'?: number + 'Comfy.Node.AutoSnapLinkToSlot'?: boolean + 'Comfy.Node.SnapHighlightsNode'?: boolean + 'Comfy.Server.ServerConfigValues'?: Record + 'Comfy.Server.LaunchArgs'?: Record + 'LiteGraph.Canvas.MaximumFps'?: number + 'Comfy.Workflow.ConfirmDelete'?: boolean + } + > + > +> + +declare const zStatusWsMessage: z.ZodObject< + { + status: z.ZodOptional< + z.ZodNullable< + z.ZodObject< + { + exec_info: z.ZodObject< + { + queue_remaining: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + queue_remaining?: number + }, + { + queue_remaining?: number + } + > + }, + 'strip', + z.ZodTypeAny, + { + exec_info?: { + queue_remaining?: number + } + }, + { + exec_info?: { + queue_remaining?: number + } + } + > + > + > + sid: z.ZodOptional> + }, + 'strip', + z.ZodTypeAny, + { + status?: { + exec_info?: { + queue_remaining?: number + } + } + sid?: string + }, + { + status?: { + exec_info?: { + queue_remaining?: number + } + } + sid?: string + } +> + +declare const zStatusWsMessageStatus: z.ZodObject< + { + exec_info: z.ZodObject< + { + queue_remaining: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + queue_remaining?: number + }, + { + queue_remaining?: number + } + > + }, + 'strip', + z.ZodTypeAny, + { + exec_info?: { + queue_remaining?: number + } + }, + { + exec_info?: { + queue_remaining?: number + } + } +> + +declare const zSystemStats: z.ZodObject< + { + system: z.ZodObject< + { + os: z.ZodString + python_version: z.ZodString + embedded_python: z.ZodBoolean + comfyui_version: z.ZodString + pytorch_version: z.ZodString + argv: z.ZodArray + ram_total: z.ZodNumber + ram_free: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + os?: string + python_version?: string + embedded_python?: boolean + comfyui_version?: string + pytorch_version?: string + argv?: string[] + ram_total?: number + ram_free?: number + }, + { + os?: string + python_version?: string + embedded_python?: boolean + comfyui_version?: string + pytorch_version?: string + argv?: string[] + ram_total?: number + ram_free?: number + } + > + devices: z.ZodArray< + z.ZodObject< + { + name: z.ZodString + type: z.ZodString + index: z.ZodNumber + vram_total: z.ZodNumber + vram_free: z.ZodNumber + torch_vram_total: z.ZodNumber + torch_vram_free: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + type?: string + name?: string + index?: number + vram_total?: number + vram_free?: number + torch_vram_total?: number + torch_vram_free?: number + }, + { + type?: string + name?: string + index?: number + vram_total?: number + vram_free?: number + torch_vram_total?: number + torch_vram_free?: number + } + >, + 'many' + > + }, + 'strip', + z.ZodTypeAny, + { + system?: { + os?: string + python_version?: string + embedded_python?: boolean + comfyui_version?: string + pytorch_version?: string + argv?: string[] + ram_total?: number + ram_free?: number + } + devices?: { + type?: string + name?: string + index?: number + vram_total?: number + vram_free?: number + torch_vram_total?: number + torch_vram_free?: number + }[] + }, + { + system?: { + os?: string + python_version?: string + embedded_python?: boolean + comfyui_version?: string + pytorch_version?: string + argv?: string[] + ram_total?: number + ram_free?: number + } + devices?: { + type?: string + name?: string + index?: number + vram_total?: number + vram_free?: number + torch_vram_total?: number + torch_vram_free?: number + }[] + } +> + +declare const zUser: z.ZodObject< + { + storage: z.ZodEnum<['server']> + migrated: z.ZodOptional + users: z.ZodOptional> + }, + 'strip', + z.ZodTypeAny, + { + storage?: 'server' + migrated?: boolean + users?: Record + }, + { + storage?: 'server' + migrated?: boolean + users?: Record + } +> + +declare const zUserDataFullInfo: z.ZodObject< + { + path: z.ZodString + size: z.ZodNumber + modified: z.ZodNumber + }, + 'strip', + z.ZodTypeAny, + { + path?: string + size?: number + modified?: number + }, + { + path?: string + size?: number + modified?: number + } +> + +export {} + +declare global { + const app: ComfyApp +} diff --git a/src/ts/.mock/scripts/api.ts b/src/ts/.mock/scripts/api.ts new file mode 100644 index 0000000..b784e4b --- /dev/null +++ b/src/ts/.mock/scripts/api.ts @@ -0,0 +1,3 @@ +import type { ComfyApi } from '@comfyorg/comfyui-frontend-types' + +export declare const api: ComfyApi diff --git a/src/ts/.mock/scripts/app.ts b/src/ts/.mock/scripts/app.ts new file mode 100644 index 0000000..0f4c1e7 --- /dev/null +++ b/src/ts/.mock/scripts/app.ts @@ -0,0 +1,3 @@ +import type { ComfyApp } from '@comfyorg/comfyui-frontend-types' + +export declare const app: ComfyApp diff --git a/src/ts/.mock/scripts/ui.ts b/src/ts/.mock/scripts/ui.ts new file mode 100644 index 0000000..d8a2f7e --- /dev/null +++ b/src/ts/.mock/scripts/ui.ts @@ -0,0 +1,3 @@ +import type { $el as $el_type } from '~/.d.ts/comfyui-frontend-types_alt.js' + +export declare const $el: typeof $el_type diff --git a/src/ts/.mock/scripts/ui/components/asyncDialog.ts b/src/ts/.mock/scripts/ui/components/asyncDialog.ts new file mode 100644 index 0000000..bfef031 --- /dev/null +++ b/src/ts/.mock/scripts/ui/components/asyncDialog.ts @@ -0,0 +1,3 @@ +import type { ComfyAsyncDialog as ComfyAsyncDialog_type } from '~/.d.ts/comfyui-frontend-types_alt.js' + +export declare const ComfyAsyncDialog: typeof ComfyAsyncDialog_type diff --git a/src/ts/.mock/scripts/widgets.ts b/src/ts/.mock/scripts/widgets.ts new file mode 100644 index 0000000..f6bc6b3 --- /dev/null +++ b/src/ts/.mock/scripts/widgets.ts @@ -0,0 +1,3 @@ +import type { ComfyWidgets as ComfyWidgets_type } from '~/.d.ts/comfyui-frontend-types_alt.js' + +export declare const ComfyWidgets: typeof ComfyWidgets_type diff --git a/src/ts/custom.ts b/src/ts/custom.ts new file mode 100644 index 0000000..ca15ba8 --- /dev/null +++ b/src/ts/custom.ts @@ -0,0 +1,332 @@ +import type { + LGraphNode, + IWidget, + INodeInputSlot, + INodeOutputSlot, +} from '@comfyorg/litegraph' + +import type { ComfyNodeDef } from '~/.d.ts/comfyui-frontend-types_alt.js' +import { slotShapes } from '~/shared/utils.js' + +type Scope = 'widget' | 'input' | 'output' +type Slot = Exclude +type NodeItems = IWidget[] | INodeInputSlot[] | INodeOutputSlot[] | undefined +type CustomLook = { + [key in Slot]?: Record< + string, + { + shape?: keyof typeof slotShapes + color_on?: string + color_off?: string + } + > +} + +const customLabels = { + // PLOT + XYPlotQueue: { + widget: { + max_dim1_per_page: 'dim1: max per page', + max_dim2_per_page: 'dim2: max per page', + }, + input: { + dim2: 'dim2 (opt)', + }, + output: { + dim1_value: 'dim1 value', + dim2_value: 'dim2 value', + xy_plot_data: 'XY plot data', + }, + }, + XYPlotRender: { + input: { + xy_plot_data: 'XY plot data', + plot_config_grid: 'config: grid (opt)', + plot_config_header: 'config: header (opt)', + plot_config_footer: 'config: footer (opt)', + }, + widget: { + dim1_header_format: 'dim1: header format', + dim2_header_format: 'dim2: header format', + }, + }, + PlotConfigGrid: { + widget: { + gap: 'gap (between cells)', + background_color: 'background color', + font_size: 'font size', + font_color: 'font color', + pad_col_headers: 'col headers: padding', + pad_row_headers: 'row headers: padding', + wrap_col_headers: 'col headers: wrap', + wrap_row_headers: 'row headers: wrap', + }, + output: { + plot_config_grid: 'config: grid', + }, + }, + PlotConfigHF: { + widget: { + text_left: 'text (left)', + text_center: 'text (center)', + text_right: 'text (right)', + background_color: 'background color', + font: 'font', + font_size: 'font size', + font_color: 'font color', + padding: 'padding', + }, + output: { + plot_config_hf: 'config: header / footer', + }, + }, + XYPlotDataSplit: { + input: { + xy_plot_data: 'XY plot data', + }, + output: { + current_page: 'current page', + total_pages: 'total pages', + }, + }, + // LIST + ListFromMultiline: { + widget: { + strip_comments: 'strip comments', + }, + }, + ListFromFile: { + widget: { + file_path: 'path', + strip_comments: 'strip comments', + }, + }, + ListLimit: { + widget: { + nb_elements: 'nb of elements', + }, + }, + // CONFIG + OutputConfigBackend: { + widget: { + file_path: 'JSON or YAML file (backend)', + show_config: 'show config', + error_display: 'display errors', + }, + }, + OutputConfigLocal: { + widget: { + error_display: 'display errors', + show_config: 'show config', + }, + }, + OutputConfigAuto: { + widget: { + auto_connect: 'auto-connect?', + multi_nodes: 'if multiple nodes found', + error_display: 'display errors', + show_config: 'show config', + }, + }, + NodeConfigApplyLocal: { + widget: { + error_display: 'display errors', + check_level: 'reject on', + }, + }, + MultiConfigFetch: { + widget: { + node_by: 'identify nodes by', + }, + }, + MultiConfigApplyLocal: { + widget: { + error_display: 'display errors', + check_level: 'reject on', + }, + }, + // QUEUE + GenericQueue: { + input: { + input_list: 'input list', + }, + }, + FileQueue: { + widget: { + pattern: 'pattern(s)', + recursive: 'recursive?', + with_extension: 'with extension?', + }, + output: { + full_path: 'full path', + relative_path: 'relative path', + }, + }, + ImageQueue: { + widget: { + pattern: 'pattern(s)', + recursive: 'recursive?', + with_extension: 'with extension?', + }, + output: { + full_path: 'full path', + relative_path: 'relative path', + }, + }, + // INPUT + InputFolder: { + widget: { + path: 'folder path', + check_exists: 'check folder existence', + }, + }, + InputMultiline: { + widget: { + strip_comments: 'strip comments', + }, + }, + // UTILS + LoadImageRGBA: { + widget: { + with_extension: 'with extension?', + mask_precision: 'mask method', + }, + }, +} as const as Record }> + +const customLooks = { + // PLOT + XYPlotQueue: { + input: { + dim1: { + shape: 'grid', + }, + dim2: { + shape: 'grid', + }, + }, + output: { + xy_plot_data: { + color_off: '#52395B', + color_on: '#9521c3', + }, + }, + }, + XYPlotRender: { + input: { + xy_plot_data: { + color_off: '#52395B', + color_on: '#9521c3', + }, + }, + }, + // LIST + ListFromString: { + output: { + list: { shape: 'grid' }, + }, + }, + ListFromMultiline: { + output: { + list: { shape: 'grid' }, + }, + }, + ListFromFile: { + output: { + list: { shape: 'grid' }, + }, + }, + ListFromElements: { + output: { + list: { shape: 'grid' }, + }, + }, + ListMerge: { + output: { + list: { shape: 'grid' }, + }, + }, + ListLimit: { + output: { + list: { shape: 'grid' }, + }, + }, +} as const as Record + +function setNodeLabels(nodeType: typeof LGraphNode, nodeData: ComfyNodeDef) { + const nodeName = nodeData.name + // early exit + if (!nodeName || !Object.keys(customLabels).includes(nodeName)) return + + const original_onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function (...args: unknown[]) { + const r = original_onNodeCreated.apply(this, args) + for (const [scope, scope_entry] of Object.entries( + customLabels[nodeName as keyof typeof customLabels], + )) { + for (const [name, label] of Object.entries( + scope_entry as Record, + )) { + // setSingleLabel(this, scope as Scope, name, label) + let nodeItems: NodeItems = undefined + switch (scope as Scope) { + case 'input': + nodeItems = this.inputs + break + case 'output': + nodeItems = this.outputs + break + case 'widget': + nodeItems = this.widgets + break + } + const item = nodeItems?.find((i) => i.name === name) + if (item) item.label = label + } + } + return r + } +} + +function setNodeLooks(nodeType: typeof LGraphNode, nodeData: ComfyNodeDef) { + const nodeName = nodeData.name + // early exit + if (!nodeName || !Object.keys(customLooks).includes(nodeName)) return + + const original_onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function (...args: unknown[]) { + const r = original_onNodeCreated.apply(this, args) + for (const [scope, scope_entry] of Object.entries( + customLooks[nodeName as keyof typeof customLooks], + )) { + for (const [name, lookEntry] of Object.entries(scope_entry)) { + let nodeItems: NodeItems = undefined + switch (scope) { + case 'input': + nodeItems = this.inputs + break + case 'output': + nodeItems = this.outputs + break + } + const item = nodeItems?.find((i) => i.name === name) + if (item) { + for (const [lookName, lookValue] of Object.entries(lookEntry)) { + if (lookName === 'shape') + item[lookName] = slotShapes[lookValue as keyof typeof slotShapes] + else item[lookName] = lookValue + } + } + } + } + return r + } +} + +export function customizeNode( + nodeType: typeof LGraphNode, + nodeData: ComfyNodeDef, +) { + setNodeLabels(nodeType, nodeData) + setNodeLooks(nodeType, nodeData) +} diff --git a/src/ts/nodes/config.ts b/src/ts/nodes/config.ts new file mode 100644 index 0000000..e55beb8 --- /dev/null +++ b/src/ts/nodes/config.ts @@ -0,0 +1,307 @@ +import type { LGraphNode, IWidget } from '@comfyorg/litegraph' + +import { + findWidget, + ALL_CONFIG_FILE_TYPES, + humanFileType, + guessFileType, + loadTextFile, + retrievefile, + forceMouseEvent, + removeAllOutputs, +} from '~/shared/utils.js' +import { + makeTextWidget, + makeButtonWidget, + makeToggleWidget, + type ISwitchWidget, + makeSwitchWidget, +} from '~/widgets/factories.js' +import { ERROR_DISPLAY, type ErrorDisplayChoices } from '~/widgets/misc.js' +import { type IConfigValidationResult } from '~/shared/config.common.js' +import { + type IOutputParsed, + type IOutputErrors, + processOutputConfigLocal, +} from '~/shared/config.output.js' +import { displaySingleError, displayErrorDict } from '~/shared/error.js' + +async function processOutputResult( + node: LGraphNode, + result: IConfigValidationResult, + dataWidget: IWidget, + statusWidget: IWidget, + errorDisplay: ErrorDisplayChoices, +) { + if (!result) return // empty path or config + const title = node.title || node.type + switch (result.success) { + case false: + dataWidget.value = {} + statusWidget.label = result.error + await displaySingleError(title, errorDisplay, result.error) + break + case true: + dataWidget.value = result.data + statusWidget.label = 'All outputs generated' + break + case 'partial': { + dataWidget.value = result.data + const message = `${result.nbErrors} error${result.nbErrors > 1 ? 's' : ''} detected` + statusWidget.label = message + await displayErrorDict(title, errorDisplay, result.errors, message) + } + } +} + +async function processOutputConfigUI( + node: LGraphNode, + switchWidget: ISwitchWidget, + configWidget: IWidget, + dataWidget: IWidget, + statusWidget: IWidget, + errorDisplayWidget: IWidget, +) { + let res + await switchWidget.guard(async () => { + // generate outputs + res = await processOutputConfigLocal(node, configWidget.value || undefined) + }) + + // process result + const result = res as IConfigValidationResult + if (!result || result.success === false) configWidget.value = '' + await processOutputResult( + node, + result, + dataWidget, + statusWidget, + errorDisplayWidget.selected, + ) + // save statusWidget label to value, to ensure it is serialized and restored on page refresh + statusWidget.value = statusWidget.label +} + +export function OutputConfigBackend( + nodeType: LGraphNode, + // _nodeData: ComfyNodeDef, + // app: ComfyApp, +) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function (...args: unknown[]) { + original_onNodeCreated?.apply(this, ...args) + // get existing widgets and add the button + const pathWidget = makeTextWidget(this, 'file_path', { + multiline: false, + placeholder: 'path to file (backend)', + default: '', + tooltip: 'full path to file (backend)', + }) + const retrieveButtonWidget = makeButtonWidget( + this, + 'retrieve', + 'Retrieve output config', + { + disabled: true, + tooltip: 'retrieve output config from a backend JSON or YAML file', + }, + ) + const errorDisplayWidget = ERROR_DISPLAY(this) + const showConfigWidget = makeToggleWidget(this, 'show_config', { + default: true, + }) + const configWidget = makeTextWidget(this, 'config', { + multiline: true, + placeholder: 'output config', + default: '', + tooltip: 'output config as JSON or YAML', + disabled: true, + }) + const filenameWidget = makeTextWidget(this, 'filename', { + multiline: false, + disabled: true, + label: 'no file', + }) + const statusWidget = makeButtonWidget(this, 'status', 'No file selected', { + tooltip: 'status', + disabled: true, + }) + const switchWidget = makeSwitchWidget(this, 'switch', [configWidget]) + const dataWidget = findWidget(this, 'data') + // implement logic + pathWidget.callback = (text: string) => { + retrieveButtonWidget.disabled = !text + } + showConfigWidget.callback = (value: boolean) => { + switchWidget.switch(value) + } + retrieveButtonWidget.callback = async () => { + // load file content to config widget + filenameWidget.label = 'no file' + filenameWidget.value = '' + configWidget.value = '' + statusWidget.label = 'Retrieving file...' + try { + const retrieved = await retrievefile(pathWidget.value) + filenameWidget.label = `file: (${humanFileType(retrieved.mime)})` + filenameWidget.value = retrieved.filename + configWidget.value = retrieved.content + await processOutputConfigUI( + this, + switchWidget, + configWidget, + dataWidget, + statusWidget, + errorDisplayWidget, + ) + } catch (e) { + statusWidget.label = (e as Error).message + dataWidget.value = {} + await switchWidget.guard(async () => { + removeAllOutputs(this) + for (const w of this.widgets) { + delete w.y + delete w.last_y + } + }) + await displaySingleError( + this.title || this.type, + errorDisplayWidget.selected, + (e as Error).message, + ) + } finally { + // strange behavior here: the widgets values are not saved, until there is any sort of mouse event. + // that can be select node, resize it, activate a widget, even just click on canvas. + // this doesn't seem to appear on exception catch, but just in case we put that in a finally block. + forceMouseEvent() + } + } + } + + const original_onConfigure = nodeType.prototype.onConfigure + nodeType.prototype.onConfigure = function (...args: unknown[]) { + original_onConfigure?.apply(this, ...args) + console.log('OutputConfigBackend / onConfigure') + // restore file and status labels + const statusWidget = findWidget(this, 'status') + if (statusWidget.value) statusWidget.label = statusWidget.value + const filenameWidget = findWidget(this, 'filename') + filenameWidget.label = 'no file' + if (filenameWidget.value) { + // we do not have access to the MIME type anymore, so try to guess + const ext = filenameWidget.value.split('.').pop() + if (ext === 'json') filenameWidget.label = 'file: (json)' + else if (['yml', 'yaml'].includes(ext)) + filenameWidget.label = 'file: (yaml)' + else filenameWidget.label = 'file:' + } + // restore button state + const retrieveButtonWidget = findWidget(this, 'retrieve') + const pathWidget = findWidget(this, 'file_path') + retrieveButtonWidget.disabled = !pathWidget.value + // hide preview if needed + const showConfigWidget = findWidget(this, 'show_config') + if (!showConfigWidget.value) showConfigWidget.callback(false) + } +} + +export function OutputConfigLocal( + nodeType: LGraphNode, + // nodeData: ComfyNodeDef, + // _app: ComfyApp, +) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function (...args: unknown[]) { + original_onNodeCreated?.apply(this, ...args) + // define widgets here, to prevent them from being converted to inputs + const loadButtonWidget = makeButtonWidget( + this, + 'load', + 'Load output config', + { + tooltip: 'load output config from a local JSON or YAML file', + }, + ) + const errorDisplayWidget = ERROR_DISPLAY(this) + const showConfigWidget = makeToggleWidget(this, 'show_config', { + default: true, + }) + const configWidget = makeTextWidget(this, 'config', { + multiline: true, + placeholder: 'output config', + default: '', + tooltip: 'output config as JSON or YAML', + disabled: true, + }) + const filenameWidget = makeTextWidget(this, 'filename', { + multiline: false, + disabled: true, + label: 'no file', + }) + const statusWidget = makeButtonWidget(this, 'status', 'No file selected', { + tooltip: 'status', + disabled: true, + }) + const switchWidget = makeSwitchWidget(this, 'switch', [configWidget]) + const dataWidget = findWidget(this, 'data') + // implement logic + showConfigWidget.callback = (value: boolean) => { + switchWidget.switch(value) + } + loadButtonWidget.callback = async () => { + try { + const loaded = await loadTextFile(ALL_CONFIG_FILE_TYPES) + if (loaded) { + filenameWidget.label = `file: (${humanFileType(loaded.type)})` + filenameWidget.value = loaded.name + configWidget.value = loaded.content + } else { + return + } + } catch (e) { + statusWidget.label = (e as Error).message + configWidget.value = '' + dataWidget.value = {} + await switchWidget.guard(async () => { + removeAllOutputs(this) + for (const w of this.widgets) { + delete w.y + delete w.last_y + } + }) + await displaySingleError( + this.title || this.type, + errorDisplayWidget.selected, + 'Content is not JSON or YAML', + ) + return + } + + await processOutputConfigUI( + this, + switchWidget, + configWidget, + dataWidget, + statusWidget, + errorDisplayWidget, + ) + } + } + + const original_onConfigure = nodeType.prototype.onConfigure + nodeType.prototype.onConfigure = function (...args: unknown[]) { + original_onConfigure?.apply(this, ...args) + // restore file and status labels + const statusWidget = findWidget(this, 'status') + if (statusWidget.value) statusWidget.label = statusWidget.value + const filenameWidget = findWidget(this, 'filename') + filenameWidget.label = 'no file' + if (filenameWidget.value) { + // we do not have access to the MIME type anymore, so try to guess + filenameWidget.label = guessFileType(filenameWidget.value) + } + // hide preview if needed + const showConfigWidget = findWidget(this, 'show_config') + if (!showConfigWidget.value) showConfigWidget.callback(false) + } +} diff --git a/src/ts/nodes/debug.ts b/src/ts/nodes/debug.ts new file mode 100644 index 0000000..96a557b --- /dev/null +++ b/src/ts/nodes/debug.ts @@ -0,0 +1,114 @@ +import type { LGraphNode } from '@comfyorg/litegraph' + +import { loadTextFile } from '~/shared/utils.js' +import { + makeTextWidget, + makeButtonWidget, + makeToggleWidget, + makeSwitchWidget, +} from '~/widgets/factories.js' +import { parseConfig } from '~/shared/config.common.js' +import { log } from '~/shared/common.js' + +export function DebugJSONYAML( + nodeType: LGraphNode, + // nodeData: ComfyNodeDef, + // _app: ComfyApp, +) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function (...args: unknown[]) { + original_onNodeCreated?.apply(this, ...args) + // load file + const loadButtonWidget = makeButtonWidget(this, 'load', 'Load file', { + tooltip: 'load a JSON or YAML file', + }) + const fileTypeWidget = makeTextWidget(this, 'file_type', { + multiline: false, + placeholder: '', + default: 'unknown', + tooltip: 'content type as detected on file load', + }) + fileTypeWidget.disabled = true + const contentWidget = makeTextWidget(this, 'content', { + multiline: true, + placeholder: 'loaded content', + default: '{}', + tooltip: 'loaded content', + }) + const parsedTypeWidget = makeTextWidget(this, 'parsed_type', { + multiline: false, + placeholder: '', + default: 'unknown', + tooltip: 'content type as detected on parse', + }) + parsedTypeWidget.disabled = true + + // load file to text area + loadButtonWidget.callback = async () => { + fileTypeWidget.value = 'unknown' + parsedTypeWidget.value = 'unknown' + const loaded = await loadTextFile( + '.json,.yaml,.yml,application/JSON,application/yaml', + ) + if (loaded) { + fileTypeWidget.value = loaded.type + try { + const parsed = await parseConfig(loaded.content) + parsedTypeWidget.value = parsed.type + contentWidget.value = parsed.prettified + } catch (e) { + parsedTypeWidget.value = (e as Error).message + contentWidget.value = '' + } + } + this.setDirtyCanvas(true) + } + } +} + +export function DebugWidgetVisibility( + nodeType: LGraphNode, + // nodeData: ComfyNodeDef, + // _app: ComfyApp, +) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function (...args: unknown[]) { + original_onNodeCreated?.apply(this, ...args) + // add widgets + makeButtonWidget(this, 'button1', 'a button', {}) + const showWidget = makeToggleWidget(this, 'show', { + default: true, + }) + const multi1Widget = makeTextWidget(this, 'multiline1', { + multiline: true, + default: 'multiline1', + }) + const text1Widget = makeTextWidget(this, 'text1', { + multiline: false, + default: 'string #1', + }) + const text2Widget = makeTextWidget(this, 'text2', { + multiline: false, + default: 'string #2', + }) + const multi2Widget = makeTextWidget(this, 'multiline2', { + multiline: true, + default: 'multiline2', + }) + makeTextWidget(this, 'footer', { + multiline: false, + default: 'footer', + }) + const switchWidget = makeSwitchWidget( + this, + 'switch', + [multi1Widget, text1Widget], + [text2Widget, multi2Widget], + ) + // implement logic + showWidget.callback = (value: boolean) => { + switchWidget.switch(value) + log.debug('switch value', switchWidget.value) + } + } +} diff --git a/src/ts/nodes/input.ts b/src/ts/nodes/input.ts new file mode 100644 index 0000000..ddd586f --- /dev/null +++ b/src/ts/nodes/input.ts @@ -0,0 +1,25 @@ +import type { LGraphNode } from '@comfyorg/litegraph' + +import { findWidget, loadTextFile } from '~/shared/utils.js' + +export function InputMultiline( + nodeType: LGraphNode, + // nodeData: ComfyNodeDef, + // _app: ComfyApp, +) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function (...args: unknown[]) { + original_onNodeCreated?.apply(this, ...args) + // load file + const loadButtonWidget = findWidget(this, 'load') + const textWidget = findWidget(this, 'multiline') + + // load file to text area + loadButtonWidget.callback = async () => { + const loaded = await loadTextFile('text/*') + if (loaded) { + textWidget.value = loaded.content + } + } + } +} diff --git a/src/ts/nodes/list.ts b/src/ts/nodes/list.ts new file mode 100644 index 0000000..806e883 --- /dev/null +++ b/src/ts/nodes/list.ts @@ -0,0 +1,25 @@ +import type { LGraphNode } from '@comfyorg/litegraph' + +import { findWidget, loadTextFile } from '~/shared/utils.js' + +export function ListFromMultiline( + nodeType: LGraphNode, + // nodeData: ComfyNodeDef, + // _app: ComfyApp, +) { + const original_onNodeCreated = nodeType.prototype.onNodeCreated + nodeType.prototype.onNodeCreated = function (...args: unknown[]) { + original_onNodeCreated?.apply(this, ...args) + // load file + const loadButtonWidget = findWidget(this, 'load') + const textWidget = findWidget(this, 'multiline') + + // load file to text area + loadButtonWidget.callback = async () => { + const loaded = await loadTextFile('text/*') + if (loaded) { + textWidget.value = loaded.content + } + } + } +} diff --git a/src/ts/register.ts b/src/ts/register.ts new file mode 100644 index 0000000..1129e01 --- /dev/null +++ b/src/ts/register.ts @@ -0,0 +1,89 @@ +import type { LGraphNode } from '@comfyorg/litegraph' + +import { app } from '~/.mock/scripts/app.js' +import type { ComfyNodeDef } from '~/.d.ts/comfyui-frontend-types_alt.js' + +import { CATEGORY, type GlobalThisWithCategory } from '~/shared/common.js' +import { customizeNode } from '~/custom.js' +import { setupDynamicConnections } from '~/shared/dynamic_connections.js' +import { QUEUE_STATUS } from '~/widgets/queue.js' +import { HIDDEN, BTN, ERROR_DISPLAY } from '~/widgets/misc.js' +import { OutputConfigBackend, OutputConfigLocal } from '~/nodes/config.js' +import { ListFromMultiline } from '~/nodes/list.js' +import { InputMultiline } from '~/nodes/input.js' +import { DebugJSONYAML, DebugWidgetVisibility } from '~/nodes/debug.js' + +type GlobalThis = typeof globalThis & GlobalThisWithCategory +;(globalThis as GlobalThis)[CATEGORY] = { log: 'debug' } + +app.registerExtension({ + name: 'ComfyLab.pack', + async beforeRegisterNodeDef( + nodeType: LGraphNode, + nodeData: ComfyNodeDef, + // _app: ComfyApp, + ) { + // skip the node if it's not ours + if (nodeData?.category?.split('/')[0] !== CATEGORY) { + return + } + + switch (nodeData.name) { + // LIST + case 'ListMerge': + setupDynamicConnections(nodeType, 'list', 'LIST', { + separator: ' ', + start_index: 1, + }) + break + case 'ListFromElements': + setupDynamicConnections(nodeType, 'element', '*', { + separator: ' ', + start_index: 1, + }) + break + // INPUT + case 'InputMultiline': + InputMultiline(nodeType) + break + // UTILS + case 'FormatString': + case 'FormatMultiline': + setupDynamicConnections(nodeType, 'arg', 'STRING,INT,FLOAT,BOOLEAN', { + separator: '', + start_index: 0, + }) + break + case 'ListFromMultiline': + ListFromMultiline(nodeType) + break + // DEBUG + case 'DebugJSONYAML': + DebugJSONYAML(nodeType) + break + case 'DebugWidgetVisibility': + DebugWidgetVisibility(nodeType) + break + // CONFIG + case 'OutputConfigBackend': + OutputConfigBackend(nodeType) + break + case 'OutputConfigLocal': + OutputConfigLocal(nodeType) + break + } + + // customize labels and looks of widgets, input / output slots + customizeNode(nodeType, nodeData) + + return nodeType + }, + getCustomWidgets() { + return { + QUEUE_STATUS, + HIDDEN, + BTN, + ERROR_DISPLAY, + } + }, +}) diff --git a/src/ts/shared/common.ts b/src/ts/shared/common.ts new file mode 100644 index 0000000..1bafbab --- /dev/null +++ b/src/ts/shared/common.ts @@ -0,0 +1,75 @@ +export const CATEGORY: string = 'ComfyLab' + +const logLevels = { + success: { level: 0, console: 'info', emoji: '👍' }, + // error: { level: 1, console: "error", emoji: "⛔" }, + error: { level: 1, console: 'error', emoji: undefined }, + // warn: { level: 2, console: "warn", emoji: "⚠️" }, + warn: { level: 2, console: 'warn', emoji: undefined }, + info: { level: 3, console: 'info', emoji: 'ℹ️' }, + // debug: { level: 4, console: "debug", emoji: "🐞" }, + debug: { level: 4, console: 'debug', emoji: undefined }, +} as const +export type LogLevels = keyof typeof logLevels + +export type GlobalThisWithCategory = Partial<{ + [key: typeof CATEGORY]: { + debug?: boolean + log?: LogLevels + } +}> + +const logger = (levelType: LogLevels, ...args: unknown[]) => { + const gt = globalThis as unknown as GlobalThisWithCategory + if ( + gt[CATEGORY]?.debug || + (gt[CATEGORY]?.log && + logLevels[gt[CATEGORY].log].level >= logLevels[levelType].level) + ) { + const level = gt[CATEGORY]?.debug + ? logLevels['debug'] + : logLevels[levelType] + if (level.emoji) console[level.console](level.emoji, ...args) + else console[level.console](...args) + } +} + +export const isObject = (variable: unknown): boolean => { + const check = Object(variable) + return ( + check && + variable === check && + typeof variable !== 'function' && + !Array.isArray(check) + ) +} + +export const inspect = (variable: unknown): void => { + if (isObject(variable)) { + for (const [name, val] of Object.entries( + variable as Record, + )) { + console.log(`${name}: `, val) + } + } else { + console.log(variable) + } +} + +export const log = { + success: (...args: unknown[]) => logger('success', `${CATEGORY}:`, ...args), + error: (...args: unknown[]) => logger('error', `${CATEGORY}:`, ...args), + warn: (...args: unknown[]) => logger('warn', `${CATEGORY}:`, ...args), + info: (...args: unknown[]) => logger('info', `${CATEGORY}:`, ...args), + debug: (...args: unknown[]) => logger('debug', ...args), + sep: () => { + console.log('---------------------------------') + }, + inspect, +} + +export const success = log.success +export const error = log.error +export const warn = log.warn +export const info = log.info +export const debug = log.debug diff --git a/src/ts/shared/config.common.ts b/src/ts/shared/config.common.ts new file mode 100644 index 0000000..b4eade6 --- /dev/null +++ b/src/ts/shared/config.common.ts @@ -0,0 +1,31 @@ +import { fetchApi } from './utils.js' +import { IOutputParsed, IOutputErrors } from './config.output.js' + +export async function parseConfig(raw: string) { + return await fetchApi('config_parse', 'POST', { raw }) +} + +export type ApiValidationError = [string[], string] +export type WidgetValue = string | number | boolean + +export type IConfigValidationResult< + TData extends IOutputParsed, + TErrors extends IOutputErrors, +> = + | { + success: true + data: TData + applied: true + } + | { + success: 'partial' + data: TData + nbErrors: number + errors: TErrors + applied: boolean + } + | { + success: false + error: string + } + | void diff --git a/src/ts/shared/config.output.ts b/src/ts/shared/config.output.ts new file mode 100644 index 0000000..8bb0c18 --- /dev/null +++ b/src/ts/shared/config.output.ts @@ -0,0 +1,190 @@ +import type { LGraphNode, INodeOutputSlot, LLink } from '@comfyorg/litegraph' + +import { isObject } from './common.js' +import { guessOutputType, compatibleTypes } from './types.js' +import { fetchApi, slotShapes, removeAllOutputs } from './utils.js' +import { ApiValidationError, IConfigValidationResult } from './config.common.js' + +interface IOutputEntry { + value: unknown + type?: string | string[] + label?: string + tooltip?: string + shape?: keyof typeof slotShapes + color_on?: string + color_off?: string +} +type NotObject = Exclude< + unknown, + Record | { [key in string]: unknown } +> +// raw data before parse +type IOutputData = Record +// parsed data +export type IOutputParsed = Record +export type IOutputErrors = Record + +export async function processOutputConfigLocal( + node: LGraphNode, + config: string | undefined, +): Promise> { + let body = {} as { data?: IOutputData; errors?: ApiValidationError[] } + let data: IOutputData = {} + + if (config) { + try { + // load data from response + body = await fetchApi('config_validate', 'POST', { + raw: config, + schema: 'config.output', + }) + } catch (error) { + removeAllOutputs(node) + return { + success: false, + error: (error as Error).message, + } + } + + data = body.data as IOutputData + } + + const apiErrors: ApiValidationError[] = body.errors || [] + type IError = Partial> + const errors: Record = {} + // build errors + for (const [errorScope, errorType] of apiErrors) { + if (!Object.keys(errors).includes(errorScope[0])) errors[errorScope[0]] = {} + errors[errorScope[0]][errorScope[1] as keyof IOutputEntry] = errorType + } + + // no data => early exit + if (Object.keys(data).length === 0) { + removeAllOutputs(node) + return { + success: false, + error: 'No data', + } + } + + // parse data and create the output slots, filtering the ones in error + const parsed = new Map() + for (const [k, entry] of Object.entries(data)) { + if (Object.keys(errors).includes(k)) continue + const key = String(k) + let value, type + const extra_info: Record = {} // for label, tooltip, ... + if (!isObject(entry)) { + value = entry + type = guessOutputType(value) + } else { + const entryObj = entry as IOutputEntry + value = entryObj['value'] + // try to determine type + if (Object.keys(entryObj).includes('type')) { + type = entryObj['type'] + } else { + type = guessOutputType(value) + } + // get optional info: label, color, ... + // TODO: tooltip doesn't work, keep it? Or try to find a way, maybe w/ element.title + for (const extra of ['label', 'tooltip', 'color_on', 'color_off']) { + if (Object.keys(entryObj).includes(extra)) + extra_info[extra] = entryObj[extra as keyof IOutputEntry] + } + // special case for slot shape + if (entryObj.shape && Object.keys(slotShapes).includes(entryObj.shape)) + extra_info.shape = slotShapes[entryObj.shape] + } + // auto-set shape for lists if not specified + if (!extra_info.shape && type === 'LIST') + extra_info.shape = slotShapes['grid'] + + parsed.set(key, { + value, + type, + extra_info, + }) + } + + // create the output slots, trying to preserve the existing ones while keeping the order in the config file + const existingLinks: Record = {} + // remove all outputs, but keep a track of existing links if applicable + while (node.outputs?.length > 0) { + const output: INodeOutputSlot = node.outputs[0] + const entry = parsed.get(output.name) + // only keep a track if name, label and type are identical, and if there are links + if ( + entry && + compatibleTypes(entry.type, output.type) && + entry.extra_info.label === output.label && + output.links && + output.links.length + ) { + const links: LLink[] = [] + for (const l of output.links) { + const link = node.graph.links.get(l) + if (link) links.push(link) + } + if (links.length) existingLinks[output.name] = links + } + node.removeOutput(0) + } + + // add the outputs from parsed, and recreate previous connections + for (const [name, entry] of parsed.entries()) { + node.addOutput(name, entry.type, entry.extra_info) + // recreate links + const links = existingLinks[name] + if (links) { + for (const link of links) { + const targetNode = node.graph._nodes_by_id[link.target_id] + node.connect(name, targetNode, link.target_slot) + } + } + } + + // parse the errors to have explicit labels + const errorLabels: Record = {} + let nbErrors = 0 + for (const [output, props] of Object.entries(errors)) { + errorLabels[output] = [] + for (const [prop, errorType] of Object.entries(props)) { + nbErrors++ + if (errorType === 'required') { + errorLabels[output].push(`'${prop}' is required`) + continue + } + let label = `'${prop}' ` + switch (prop) { + case 'type': + label += 'should be a string, or a list of strings' + break + case 'label': + case 'tooltip': + case 'color_off': + case 'color_on': + label += 'should be a string' + break + case 'shape': + label += "should be one of: 'box', 'circle', 'arrow', 'grid'" + break + } + errorLabels[output].push(label) + } + } + if (nbErrors === 0) + return { + success: true, + data: Object.fromEntries(parsed), + applied: true, + } + else + return { + success: 'partial', + data: Object.fromEntries(parsed), + nbErrors, + errors: errorLabels, + applied: true, + } +} diff --git a/src/ts/shared/dynamic_connections.ts b/src/ts/shared/dynamic_connections.ts new file mode 100644 index 0000000..326c5d2 --- /dev/null +++ b/src/ts/shared/dynamic_connections.ts @@ -0,0 +1,320 @@ +// See: https://github.com/melMass/comfy_mtb/blob/main/web/comfy_shared.js#L399 + +import { app } from '~/.mock/scripts/app.js' +import type { + LGraphNode, + LLink, + IWidget, + INodeInputSlot, + INodeOutputSlot, + ISlotType, +} from '@comfyorg/litegraph' + +type INodesFromLink = { + to: LGraphNode + from: LGraphNode + type: 'error' | 'incoming' | 'outgoing' +} +/** + * @param {LGraphNode} node + * @param {LLink} link + * @returns {{to:LGraphNode, from:LGraphNode, type:'error' | 'incoming' | 'outgoing'}} + */ +export const nodesFromLink = ( + node: LGraphNode, + link: LLink, +): INodesFromLink => { + const fromNode = app.graph.getNodeById(link.origin_id) + const toNode = app.graph.getNodeById(link.target_id) + + let tp: INodesFromLink['type'] = 'error' + + if (fromNode.id === node.id) { + tp = 'outgoing' + } else if (toNode.id === node.id) { + tp = 'incoming' + } + + return { to: toNode, from: fromNode, type: tp } +} + +type IOnConnectionsChangeParams = { + type: ISlotType + slotIndex: number + isConnected: boolean + link: LLink + ioSlot: INodeInputSlot | INodeOutputSlot +} +interface ISetupDynamicConnectionsOpts { + separator?: string + start_index?: number + link?: LLink + ioSlot?: INodeInputSlot | INodeOutputSlot + DEBUG?: { + node: LGraphNode + } & IOnConnectionsChangeParams +} +/** + * @param {NodeType} nodeType The nodetype to attach the documentation to + * @param {str} prefix A prefix added to each dynamic inputs + * @param {str | [str]} inputType The datatype(s) of those dynamic inputs + * @param {{separator?:string, start_index?:number, link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}?} [opts] Extra options + * @returns + */ +export const setupDynamicConnections = ( + nodeType: LGraphNode, + prefix: string, + inputType: string | string[], + opts: ISetupDynamicConnectionsOpts | undefined = undefined, +) => { + // console.log( + // "Setting up dynamic connections for", + // Object.getOwnPropertyDescriptors(nodeType).title.value + // ); + + /** @type {{separator:string, start_index:number, link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}?} */ + // const options = opts || {}; + const options = Object.assign( + { + separator: '_', + start_index: 1, + }, + opts || {}, + ) + const onNodeCreated = nodeType.prototype.onNodeCreated + const inputList = typeof inputType === 'object' + + nodeType.prototype.onNodeCreated = function () { + const r = onNodeCreated ? onNodeCreated.apply(this, []) : undefined + this.addInput( + `${prefix}${options.separator}${options.start_index}`, + inputList ? '*' : inputType, + ) + return r + } + + const onConnectionsChange = nodeType.prototype.onConnectionsChange + /** + * @param {OnConnectionsChangeParams} args + */ + nodeType.prototype.onConnectionsChange = function (...args: unknown[]) { + const [type, slotIndex, isConnected, link, ioSlot] = args + + options.link = link + options.ioSlot = ioSlot + const r = onConnectionsChange + ? onConnectionsChange.apply(this, [ + type, + slotIndex, + isConnected, + link, + ioSlot, + ]) + : undefined + options.DEBUG = { + node: this, + type, + slotIndex, + isConnected, + link, + ioSlot, + } as ISetupDynamicConnectionsOpts['DEBUG'] + + // keep a track of current size, and also the minimum / computed one + const oldSize = [this.size[0], this.size[1]] + const oldComputedSize = this.computeSize() + + dynamicConnection( + this, + slotIndex as number, + isConnected as boolean, + `${prefix}${options.separator}`, + inputType as string, + options, + ) + + // reset positions of all widgets, they will be recalculated + for (const widget of this.widgets || []) { + delete widget.y + delete widget.last_y + // computedHeight is used by the multiline widgets, it must be reset to force it to take all height + delete widget.computedHeight + } + // get the new computed size, after adding / removing inputs + const newComputedSize = this.computeSize() + // recalculate the node size: preserve width, and increase / decrease height + this.setSize([ + oldSize[0], + oldSize[1] + newComputedSize[1] - oldComputedSize[1], + ]) + + return r + } +} + +interface IDynamicConnectionOpts { + start_index?: number + link?: LLink + ioSlot?: INodeInputSlot | INodeOutputSlot + nameArray?: string[] +} +/** + * Main logic around dynamic inputs + * + * @param {LGraphNode} node - The target node + * @param {number} index - The slot index of the currently changed connection + * @param {bool} connected - Was this event connecting or disconnecting + * @param {string} [connectionPrefix] - The common prefix of the dynamic inputs + * @param {string|[string]} [connectionType] - The type of the dynamic connection + * @param {{start_index?:number, link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}} [opts] - extra options + */ +export const dynamicConnection = ( + node: LGraphNode, + index: number, + connected: boolean, + connectionPrefix: string = 'input_', + connectionType: string = '*', + opts: IDynamicConnectionOpts | undefined = undefined, +) => { + /* @type {{link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}} [opts] - extra options*/ + // const options = opts || {}; + const options = Object.assign( + { + start_index: 1, + }, + opts || {}, + ) + + // function to test if input is a dynamic one + const isDynamicInput = (inputName: string) => + inputName.startsWith(connectionPrefix) + + if (node.inputs.length > 0 && !isDynamicInput(node.inputs[index].name)) { + return + } + + const listConnection = typeof connectionType === 'object' + + const conType = listConnection ? '*' : connectionType + const nameArray = options.nameArray || [] + + const clean_inputs = () => { + if (node.inputs.length === 0) return + + // let w_count = node.widgets?.length || 0 + let i_count = node.inputs?.length || 0 + // console.log( + // `Cleaning inputs: [BEFORE] (w: ${w_count} | inputs: ${i_count})` + // ); + + const to_remove = [] + for (let n = 1; n < node.inputs.length; n++) { + const element = node.inputs[n] + if (!element.link && isDynamicInput(element.name)) { + if (node.widgets) { + const w = node.widgets.find((w: IWidget) => w.name === element.name) + if (w) { + w.onRemoved?.() + node.widgets.length = node.widgets.length - 1 + } + } + // console.log(`Removing input ${n}`); + to_remove.push(n) + } + } + for (let i = 0; i < to_remove.length; i++) { + const id = to_remove[i] + + node.removeInput(id) + i_count -= 1 + } + node.inputs.length = i_count + + // w_count = node.widgets?.length || 0 + i_count = node.inputs?.length || 0 + // console.log( + // `Cleaning inputs: [AFTER] (w: ${w_count} | inputs: ${i_count})` + // ); + + // console.log("Cleaning inputs: making it sequential again"); + // make inputs sequential again + let prefixed_idx = options.start_index + for (let i = 0; i < node.inputs.length; i++) { + // let name = `${connectionPrefix}${i + 1}`; + let name = '' + // rename only prefixed inputs + if (isDynamicInput(node.inputs[i].name)) { + // prefixed => rename and increase index + name = `${connectionPrefix}${prefixed_idx}` + prefixed_idx += 1 + } else { + // not prefixed => keep same name + name = node.inputs[i].name + } + + if (nameArray.length > 0) { + name = i < nameArray.length ? nameArray[i] : name + } + + // preserve label if it exists + node.inputs[i].label = node.inputs[i].label || name + node.inputs[i].name = name + } + } + if (!connected) { + if (!options.link) { + // console.log("Disconnecting", { options }); + + clean_inputs() + } else { + if (!options.ioSlot.link) { + node.connectionTransit = true + } else { + node.connectionTransit = false + clean_inputs() + } + // console.log("Reconnecting", { options }); + } + } + + if (connected) { + if (options.link) { + // const { from, to, type } = nodesFromLink(node, options.link) + const link = nodesFromLink(node, options.link) + if (link.type === 'outgoing') return + // console.log("Connecting", { options, from, to, type }); + } else { + // console.log("Connecting", { options }); + } + + if (node.connectionTransit) { + // console.log("In Transit"); + node.connectionTransit = false + } + + // Remove inputs and their widget if not linked. + clean_inputs() + + if (node.inputs.length === 0) return + // add an extra input + if (node.inputs[node.inputs.length - 1].link !== null) { + // const nextIndex = node.inputs.length; + + // count only the prefixed inputs + const nextIndex = node.inputs.reduce( + (acc: number, cur: INodeInputSlot) => + isDynamicInput(cur.name) ? ++acc : acc, + 0, + ) + + const name = + nextIndex < nameArray.length + ? nameArray[nextIndex] + : `${connectionPrefix}${nextIndex + options.start_index}` + + // console.log(`Adding input ${nextIndex + options.start_index} (${name})`); + + node.addInput(name, conType) + } + } +} diff --git a/src/ts/shared/error.ts b/src/ts/shared/error.ts new file mode 100644 index 0000000..fc9b569 --- /dev/null +++ b/src/ts/shared/error.ts @@ -0,0 +1,108 @@ +import { $el } from '~/.mock/scripts/ui.js' + +import { log } from '~/shared/common.js' +import { type ErrorDisplayChoices } from '~/widgets/misc.js' +import { showErrorDialog } from '~/shared/utils.js' + +export async function displaySingleError( + nodeTitle: string, + errorDisplay: ErrorDisplayChoices, + token1: string, + token2 = '', + displayTitle = true, + displayCategory = true, +) { + let message = '' + switch (errorDisplay) { + case 'browser': + message = token2 ? `${token1}: ${token2}` : token1 + if (displayTitle) log.warn(`${nodeTitle}: ${message}`) + else if (displayCategory) log.warn(message) + else console.warn(message) // useful for indented content + break + case 'dialog': + message = token2 ? `${token1}: ${token2}` : token1 + if (displayTitle) + await showErrorDialog({ + title: nodeTitle, + subtitle: '⚠️ ' + message, + centerSubtitle: true, + }) + else + await showErrorDialog({ + subtitle: '⚠️ ' + message, + centerSubtitle: true, + }) + break + default: + } +} + +export async function displayErrorDict( + nodeTitle: string, + errorDisplay: ErrorDisplayChoices, + errorDict: Record, + message = '', +) { + switch (errorDisplay) { + case 'browser': + if (message) { + await displaySingleError(nodeTitle, errorDisplay, message + ':') + } + for (const [key, err] of Object.entries(errorDict)) { + const errors = Array.isArray(err) ? err : [err] + for (const error of errors) { + // if message is displayed, do no repeat prefix for each, indent them instead + if (message) + await displaySingleError( + nodeTitle, + errorDisplay, + ` - '${key}'`, + String(error), + false, + false, + ) + else + await displaySingleError( + nodeTitle, + errorDisplay, + `Error in '${key}'`, + String(error), + ) + } + } + break + case 'dialog': { + const allErrors = [] + for (const [key, errors] of Object.entries(errorDict)) { + if (Array.isArray(errors)) { + const keyErrors = [] + for (const error of errors) { + keyErrors.push($el('li', String(error))) + } + allErrors.push( + $el('li', [ + key + ':', + $el('ul', { style: { paddingLeft: '20px' } }, keyErrors), + ]), + ) + } else { + allErrors.push($el('li', [`'${key}': ${String(errors)}`])) + } + } + await showErrorDialog({ + title: nodeTitle, + subtitle: '⚠️ ' + message, + centerSubtitle: true, + content: $el( + 'ul', + { style: { margin: '0px', paddingLeft: '0px' } }, + allErrors, + ), + centerContent: true, + }) + break + } + default: + } +} diff --git a/src/ts/shared/types.ts b/src/ts/shared/types.ts new file mode 100644 index 0000000..217bf12 --- /dev/null +++ b/src/ts/shared/types.ts @@ -0,0 +1,27 @@ +export function guessOutputType(value: unknown) { + if (Array.isArray(value)) return 'LIST' + else if (typeof value === 'number') { + // if it's an integer, return both for better compatibility + // CHECK: use NUMBER here? + return Number.isInteger(value) ? ['INT', 'FLOAT'] : 'FLOAT' + } else if (typeof value === 'bigint') return 'INT' + else if (typeof value === 'string') return 'STRING' + else if (typeof value === 'boolean') return 'BOOLEAN' + else return '*' +} + +export function compatibleTypes( + type1: string | string[], + type2: string | string[], +) { + if (!Array.isArray(type1) && !Array.isArray(type2)) return type1 === type2 + + const t1 = Array.isArray(type1) ? type1 : [type1] + const t2 = Array.isArray(type2) ? type2 : [type2] + + if (t1.length !== t2.length) return false + for (const val of t1) { + if (!t2.includes(val)) return false + } + return true +} diff --git a/src/ts/shared/utils.ts b/src/ts/shared/utils.ts new file mode 100644 index 0000000..a7ac0a0 --- /dev/null +++ b/src/ts/shared/utils.ts @@ -0,0 +1,338 @@ +import type { + LGraphNode, + IWidget, + INodeInputSlot, + INodeOutputSlot, +} from '@comfyorg/litegraph' + +import { api } from '~/.mock/scripts/api.js' +import { $el } from '~/.mock/scripts/ui.js' +import { ComfyAsyncDialog } from '~/.mock/scripts/ui/components/asyncDialog.js' + +export const findWidget = ( + node: LGraphNode, + name: string, +): IWidget | undefined => { + return node.widgets?.find((w: IWidget) => w.name === name) +} +export const findWidgetIndex = ( + node: LGraphNode, + name: string, +): number | undefined => { + return node.widgets?.findIndex((w: IWidget) => w.name === name) +} +export const findInput = ( + node: LGraphNode, + name: string, +): INodeInputSlot | undefined => { + return node.inputs?.find((i: INodeInputSlot) => i.name === name) +} +export const findWidgetOrInput = ( + node: LGraphNode, + name: string, +): IWidget | INodeInputSlot | undefined => { + return findWidget(node, name) || findInput(node, name) +} +export const findOutput = ( + node: LGraphNode, + name: string, +): INodeOutputSlot | undefined => { + return node.outputs?.find((o: INodeOutputSlot) => o.name === name) +} +export const removeWidget = (node: LGraphNode, name: string): boolean => { + const index = findWidgetIndex(node, name) + if (index && index >= 0) { + const widget = node.widgets[index] + node.widgets.splice(index, 1) + widget?.onRemove() + node.size = node.computeSize() + node.setDirtyCanvas(true, true) + return true + } else return false +} +export function removeAllOutputs(node: LGraphNode) { + while (node.outputs?.length > 0) { + node.removeOutput(0) + } +} + +type NodeLookupMode = 'id' | 'title' | 'type' +export function lookupNodes( + key: string | number, + by?: NodeLookupMode | NodeLookupMode[], + except?: LGraphNode, +): LGraphNode[] { + let modes: NodeLookupMode[] = [] + if (!by) modes = ['id', 'title', 'type'] + else if (Array.isArray(by)) modes = by + else modes = [by] + + const strKey = String(key) + const found: Set = new Set() + for (const mode of modes) { + if (mode === 'id' && !isNaN(+strKey) && Number.isInteger(+strKey)) { + const node: LGraphNode | undefined = app.graph._nodes_by_id[+strKey] + if (node && node !== except) found.add(node) + } else { + for (const node of app.graph._nodes) { + if (node[mode] === strKey && node !== except) found.add(node) + } + } + } + return Array.from(found) +} + +export const slotShapes = { + box: 1, + // round: 2, + circle: 3, + // card: 4,s + arrow: 5, + grid: 6, +} as const + +class ConfigError extends Error {} +export async function fetchApi( + entry: string, + method: 'GET' | 'POST', + params: Record, +) { + const response = await api.fetchApi('/comfylab/' + entry, { + method, + body: JSON.stringify(params), + }) + if (!response.ok) { + switch (response.status) { + case 404: + throw new ConfigError('File not found') + case 415: + throw new ConfigError(response.statusText) + case 500: + throw new ConfigError(`Internal error: ${response.statusText}`) + default: + throw new ConfigError(response.statusText) + } + } + return await response.json() +} + +type IRetrievedFile = { + filename: string + content: string + mime: string + encoding: string +} +export async function retrievefile(path: string): Promise { + const body = await fetchApi('load_file', 'POST', { path }) + return { + filename: body.filename, + content: body.content, + mime: body.mime, + encoding: body.encoding, + } +} + +export function saveToTextFile( + filename: string, + content: string, + accept = 'text/plain', +) { + const blob = new Blob([content], { type: accept + ';charset=utf-8' }), + anchor = document.createElement('a') + + anchor.download = filename + anchor.href = (window.webkitURL || window.URL).createObjectURL(blob) + anchor.dataset.downloadurl = [accept, anchor.download, anchor.href].join(':') + anchor.click() + anchor.remove() +} + +export async function loadTextFile( + accept = 'text/plain', +): Promise<{ content: string; name: string; type: string } | undefined> { + return new Promise((resolve) => { + const input = document.createElement('input') + input.type = 'file' + input.accept = accept + input.style.display = 'none' + const reader = new FileReader() + + let name: string | undefined = undefined + let contentType: string | undefined = undefined + + reader.addEventListener( + 'load', + () => { + resolve({ + content: reader.result as string, + name: name as string, + type: contentType as string, + }) + }, + { once: true }, + ) + reader.addEventListener( + 'abort', + () => { + resolve(undefined) + }, + { once: true }, + ) + reader.addEventListener( + 'error', + () => { + resolve(undefined) + }, + { once: true }, + ) + + input.addEventListener( + 'change', + (e: Event) => { + const target = e.target as HTMLInputElement + if (target.files) { + const file = target.files[0] + name = file.name + contentType = file.type + reader.readAsText(file) + } else resolve(undefined) + }, + { once: true }, + ) + input.addEventListener( + 'cancel', + () => { + resolve(undefined) + }, + { once: true }, + ) + input.click() + input.remove() + }) +} + +export async function showErrorDialog({ + title = '', + subtitle = '', + centerSubtitle = false, + content = [] as HTMLElement | HTMLElement[], + centerContent = false, +}) { + const elements = [] + if (title) { + elements.push( + $el( + 'div', + { + style: { + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + color: '#8c8c8c', + }, + }, + [$el('h3', title)], + ), + ) + } + if (subtitle) { + let subtitleEl = $el('h4', subtitle) + if (centerSubtitle) { + subtitleEl = $el( + 'div', + { + style: { + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + }, + }, + [subtitleEl], + ) + } + elements.push(subtitleEl) + } + if (content) { + if (!Array.isArray(content)) content = [content] + if (centerContent) { + content = [ + $el( + 'div', + { + style: { + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + }, + }, + content, + ), + ] + } + elements.push(...content) + } + + const dialog = new ComfyAsyncDialog() + const res = await dialog.showModal(elements) + dialog.element.remove() + return res +} + +/** + * Workaround for a strange behavior (bug?), encountered in OutputConfigBackend, + * where widgets values are not saved until there is a mouse event (anything: click on node / canvas, ...). \ + * So here basically we simulate a mouse event... + */ +export function forceMouseEvent() { + app.canvas.processMouseUp(new MouseEvent('mouseup')) +} + +/** + * Allow a widget to define an async callback, as it is not possible by default + * @param widget widget + */ +export function makeWidgetAsync(widget: IWidget) { + if (widget._event) return + + // replace callback with events + widget._event = { + target: new EventTarget(), + callback: widget.callback, + } + delete widget.callback + widget._event.target.addEventListener('change', async (ev: CustomEvent) => { + if (widget._event.callback) { + await widget._event.callback(ev.detail) + } + }) + Object.defineProperty(widget, 'callback', { + get() { + return (value: TValue) => { + widget._event.target.dispatchEvent( + new CustomEvent('change', { detail: value }), + ) + } + }, + set(cb: () => void | Promise) { + widget._event.callback = cb + }, + enumerable: true, + }) +} + +export const ALL_CONFIG_FILE_TYPES = + '.json,.jsonc,.json5,.yaml,.yml,application/JSON,application/json5,application/yaml' +export const humanFileType = (mimeType: string) => { + mimeType = mimeType.toLowerCase() + if (mimeType.includes('json5')) return 'json5' + if (mimeType.includes('json')) return 'json' + if (mimeType.includes('yaml')) return 'yaml' + return '' +} +export const guessFileType = (filename: string) => { + const ext: string = filename.split('.').pop() || '' + if (ext === 'json5') return 'file: (json5)' + if (ext === 'json' || ext === 'jsonc') return 'file: (json)' + else if (['yml', 'yaml'].includes(ext)) return 'file: (yaml)' + return 'file:' +} diff --git a/src/ts/widgets/factories.ts b/src/ts/widgets/factories.ts new file mode 100644 index 0000000..2dc8194 --- /dev/null +++ b/src/ts/widgets/factories.ts @@ -0,0 +1,367 @@ +import { LGraphNode, IWidget, Vector2 } from '@comfyorg/litegraph' + +import { app } from '~/.mock/scripts/app.js' +import { ComfyWidgets } from '~/.mock/scripts/widgets.js' + +import { findWidget, makeWidgetAsync } from '~/shared/utils.js' + +interface ITextWidgetOptions { + multiline?: boolean + placeholder?: string + default?: string + label?: string + tooltip?: string + disabled?: boolean + domStyle?: Record +} + +export function makeTextWidget( + node: LGraphNode, + name: string, + options: ITextWidgetOptions = {}, +): IWidget { + // extract the options sent to ComfyWidgets + const widgetOptions = ['multiline', 'placeholder'].reduce( + (obj: Record, optKey) => { + if (optKey in options) + obj[optKey] = options[optKey as keyof ITextWidgetOptions] + return obj + }, + {}, + ) + const widget = ComfyWidgets['STRING']( + node, + name, + ['STRING', widgetOptions], + // @ts-expect-error: issue with #private in ComfyApp definition + app, + ).widget + if (options.default) widget.value = options.default + if (options.label) widget.label = options.label + if (options.tooltip) { + if (options.multiline) widget.inputEl.title = options.tooltip + else widget.tooltip = options.tooltip + } + if (options.disabled) { + if (!options.multiline) widget.disabled = true + else { + widget.inputEl.readOnly = true + widget.inputEl.style.border = 'none' + // widget.inputEl.style.backgroundColor = 'transparent' + widget.inputEl.style.opacity = 0.6 + } + } + if (options.multiline && options.domStyle) + for (const [styleKey, styleValue] of Object.entries(options.domStyle)) { + widget.inputEl.style[styleKey] = styleValue + } + return widget +} + +interface IButtonWidgetOptions { + tooltip?: string + disabled?: boolean + async?: boolean + callback?: () => void | Promise +} + +export function makeButtonWidget( + node: LGraphNode, + name: string, + label: string, + options: IButtonWidgetOptions = {}, +): IWidget { + options = Object.assign( + { + async: true, + }, + options, + ) + const widget = node.addWidget('button', name, 0, () => {}) + widget.label = label + if (options.tooltip) widget.tooltip = options.tooltip + if (options.disabled) widget.disabled = options.disabled + + if (options.async) makeWidgetAsync(widget) + if (options.callback) widget.callback = options.callback + return widget +} + +interface IToggleWidgetOptions { + default?: boolean + label_on?: string + label_off?: string + label?: string + tooltip?: string + disabled?: boolean + callback?: () => void | Promise +} + +export function makeToggleWidget( + node: LGraphNode, + name: string, + options: IToggleWidgetOptions = {}, +): IWidget { + // extract the options sent to ComfyWidgets + const widgetOptions = ['default', 'label_on', 'label_off'].reduce( + (obj: Record, optKey) => { + if (optKey in options) + obj[optKey] = options[optKey as keyof IToggleWidgetOptions] + return obj + }, + {}, + ) + const widget = ComfyWidgets['BOOLEAN']( + node, + name, + ['STRING', widgetOptions], + // @ts-expect-error: issue with #private in ComfyApp definition + app, + ).widget + if (options.label) widget.label = options.label + if (options.tooltip) widget.tooltip = options.tooltip + if (options.disabled) widget.disabled = options.disabled + if (options.callback) widget.callback = options.callback + return widget +} + +type ComboChoices = string[] | { [key in string]: string } +type ComboSelected = keyof T +type ComboValue = T extends string[] + ? T[number] + : T[keyof T] +export type IComboWidget = IWidget & { + choices: T + selected: ComboSelected + onSelected?: (selected: ComboSelected) => void | Promise +} + +export function makeComboWidget( + node: LGraphNode, + name: string, + choices: T, + defaultSelected: ComboSelected, + onSelected?: ( + selected: ComboSelected, + label: ComboValue, + ) => void | Promise, + tooltip?: string, +): IComboWidget { + const getSelected = (label: ComboValue): ComboSelected | undefined => { + if (Array.isArray(choices)) + return choices.indexOf(label) as ComboSelected + else { + for (const [key, val] of Object.entries(choices)) { + if (val === label) return key as ComboSelected + } + } + } + const labels = Array.isArray(choices) ? choices : Object.values(choices) + const widget = node.addWidget( + 'combo', + name, + choices[defaultSelected], + () => {}, //replaced below by an async function + { values: labels }, + ) + widget.choices = choices + widget.selected = defaultSelected + widget.onSelected = onSelected + // use an EventTarget to allow async callback, and replace default one + makeWidgetAsync(widget) + widget.callback = async (label: ComboValue) => { + widget.selected = getSelected(label) + if (widget.onSelected) await widget.onSelected(widget.selected, label) + } + + if (tooltip) widget.tooltip = tooltip + + // enssure we reload the values at node.onConfigure + const original_onNodeConfigure = node.onConfigure + node.onConfigure = function (...args: unknown[]) { + widget.selected = getSelected(widget.value) + original_onNodeConfigure?.apply(this, ...args) + } + + return widget +} + +function setWidgetVisible(widget: IWidget, type: string) { + if (type === 'hidden') { + widget.hidden = true + widget.type = 'hidden' + widget.computedHeight = null + if (widget.element) { + widget.element.style.display = 'none' + widget.element.dataset.shouldHide = true + } + widget.computeSize = () => [0, -4] + } else { + delete widget.hidden + delete widget.computeSize + widget.type = type + if (widget.element) { + widget.element.style.display = null + widget.element.dataset.shouldHide = false + } + } +} + +export interface ISwitchState { + current: boolean + states: { + true: { + size: Vector2 | undefined + members: Record // widget name: type + } + false: { + size: Vector2 | undefined + members: Record // widget name: type + } + } +} + +export type ISwitchWidget = IWidget & { + switch: (current: boolean, initial?: boolean) => void + saveSize: () => void + guard: (fct: () => void | Promise) => Promise +} + +/** + * Create an hidden widget, to switch visibility of one or two groups of widgets. \ + * Use the `switch()` method to switch from one group to the other. \ + * Note: This widget is meant to be serialized, to ensure proper reload on page refresh. + * @param node node + * @param name widget name + * @param widgetGroup1 array of widgets to be visible, when current is `true` + * @param widgetGroup2 optional: array of widgets to be visible, when current is `false` + * @returns the widget + */ +export function makeSwitchWidget( + node: LGraphNode, + name: string, + widgetGroup1: IWidget[], + widgetGroup2: IWidget[] = [], +): ISwitchWidget { + // save the widget type, as we will override it later + const serializeWidgets = (widgetGroup: IWidget[]) => { + return widgetGroup + .filter((w: IWidget) => w.name !== name) + .reduce((acc, w: IWidget) => { + acc[w.name] = w.type + return acc + }, {}) + } + // initialValue: store widget types, useful when making them visible + const initialValue: ISwitchState = { + current: true, + states: { + true: { + size: undefined, + members: serializeWidgets(widgetGroup1), + }, + false: { + size: undefined, + members: serializeWidgets(widgetGroup2), + }, + }, + } + // create the hidden widget + const widget: ISwitchWidget = node.addWidget( + 'hidden', + name, + initialValue, + () => {}, + ) + widget.computeSize = () => [0, -4] + + /** + * Toggle visiblity from one group to the other. + * @param value if `true`, group1 is visible, group2 otherwise + * @param initial do not store current size, useful in `node.onConfigure()` + */ + widget.switch = (value: boolean) => { + // save current value + widget.value.current = value + const states = widget.value.states + // toggle groups visibility + // widgets to make visible: restore type + for (const [widgetName, widgetType] of Object.entries( + states[value].members, + )) { + const w = findWidget(node, widgetName) + if (w) { + setWidgetVisible(w, widgetType as string) + } + } + // widget to make invisible + for (const widgetName of Object.keys(states[!value].members)) { + const w = findWidget(node, widgetName) + if (w) { + setWidgetVisible(w, 'hidden') + } + } + // reset position for all widgets, to force recalculation + for (const w of node.widgets) { + delete w.y + delete w.last_y + } + // adjust node height; if not known, let computeSize() do the job + const height = states[value].size?.[1] || node.computeSize()[1] + node.setSize([node.size[0], height] as Vector2) // this triggers onResize() + // we do not save size here, saveSize is called by onResize (see below) + } + widget.saveSize = () => { + widget.value.states[widget.value.current].size = [ + node.size[0], + node.size[1], + ] + } + + // register to node,onResize + const original_onResize = node.onResize + node.onResize = function (size: Vector2) { + original_onResize?.apply(this, size) + // reset position for all widgets, to force recalculation + for (const w of this.widgets) { + delete w.y + delete w.last_y + delete w.computedHeight + } + widget.saveSize() + } + + // restore state on page refresh + const original_onConfigure = node.onConfigure + node.onConfigure = function (...args: unknown[]) { + original_onConfigure?.apply(this, ...args) + widget.switch(widget.value.current) + } + + /** + * Temporarily switch off then on, to let a function be executed. + * This is useful when creating new outputs for example. + * @param fct function to be executed + */ + widget.guard = async (fct: () => void | Promise) => { + // make content invisible if applicable + const contentVisible = widget.value.current + const oldSize = [node.size[0], node.size[1]] + const oldComputedSize = node.computeSize() + if (contentVisible) widget.switch(false) + await fct() + // restore content visibility if applicable + if (contentVisible) widget.switch(true) + // keep previous width, and increase/decrease height depending on new outputs + const newComputedSize = node.computeSize() + // use setSize(), to ensure saveSize() is called + node.setSize([ + oldSize[0], + oldSize[1] + newComputedSize[1] - oldComputedSize[1], + ]) + } + + widget.switch(widget.value.current) // only useful on node creation + + return widget as ISwitchWidget +} diff --git a/src/ts/widgets/misc.ts b/src/ts/widgets/misc.ts new file mode 100644 index 0000000..4e529de --- /dev/null +++ b/src/ts/widgets/misc.ts @@ -0,0 +1,134 @@ +import { LGraphNode, IWidget } from '@comfyorg/litegraph' +import type { ComfyApp } from '@comfyorg/comfyui-frontend-types' + +import { InputSpec } from '~/.d.ts/comfyui-frontend-types_alt.js' +import { + makeButtonWidget, + type IComboWidget, + makeComboWidget, +} from '~/widgets/factories.js' +import { makeWidgetAsync } from '~/shared/utils.js' + +/** + * Create an hidden widget. To be used in `getCustomWidgets(app)` + * @param {*} node + * @param {*} inputName + * @param {*} inputData + * @param {*} _app + * @returns + */ +export function HIDDEN( + node: LGraphNode, + inputName: string, + inputData: InputSpec, + // eslint-disable-next-line @typescript-eslint/no-unused-vars + _app: ComfyApp | undefined, +) { + // the value in inputData is only used when creating a new workdlow + // otherwise, the cached value will be used by Comfy + // TODO: should be default instead? If so, correct XYPlotQueue + const initialValue = inputData[1].value + // there is no callback, as it doesn't get called for non-standard widgets (see LGraphCanvas.prototype.processNodeWidgets) + // if needed, we could replace value w/ getter / setter + const widget: IWidget = { + type: 'HIDDEN', + name: inputName, + value: initialValue, + size: [0, -4], + computeSize: () => { + return [0, -4] + }, + } + node.addCustomWidget(widget) + return widget +} + +export function BTN(node: LGraphNode, inputName: string, inputData: InputSpec) { + const label = inputData[1].label || inputName + return makeButtonWidget(node, inputName, label, inputData[1]) +} + +export function NODE_COMBO(node: LGraphNode, name: string) { + type NodeListWidget = IWidget & { + selected?: number + selectedNode?: LGraphNode + onSelected?: ( + selectedId: number | undefined, + selectedNode: LGraphNode | undefined, + ) => void | Promise + } + const getNodeList = (_widget: IWidget, thisNode: LGraphNode | undefined) => { + const nodes = [''] + if (thisNode) + nodes.push( + ...thisNode.graph._nodes + .filter((otherNode: LGraphNode) => otherNode.id !== thisNode.id) + .map((otherNode: LGraphNode) => { + return `#${otherNode.id}: ${otherNode.title}` + }), + ) + return nodes + } + const getSelected = (label: string) => { + if (!label) { + return [undefined, undefined] + } else { + const selected = parseInt(label.split(':')[0].substring(1)) + return [selected, node.graph._nodes_by_id[selected]] + } + } + const widget = node.addWidget( + 'combo', + name, + '', + async function (this: NodeListWidget, label: string) { + ;[this.selected, this.selectedNode] = getSelected(label) + if (this.onSelected) + await this.onSelected(this.selected, this.selectedNode) + }, + { values: getNodeList }, + ) + + // use an EventTarget to allow async callback, and replace default one + makeWidgetAsync(widget) + widget.callback = async (label: string) => { + ;[widget.selected, widget.selectedNode] = getSelected(label) + if (widget.onSelected) + await widget.onSelected(widget.selected, widget.selectedNode) + } + + widget.tooltip = 'select node from list' + + // enssure we reload the values at node.onConfigure + const original_onNodeConfigure = node.onConfigure + node.onConfigure = function (...args: unknown[]) { + ;[widget.selected, widget.selectedNode] = getSelected(widget.value) + original_onNodeConfigure?.apply(this, ...args) + } + + return widget +} + +export const ERROR_DISPLAY_CHOICES = { + browser: 'in browser console (F12)', + dialog: 'in a popup', + none: 'do not display', +} as const +export type ErrorDisplayChoices = keyof typeof ERROR_DISPLAY_CHOICES + +export function ERROR_DISPLAY( + node: LGraphNode, + name: string = 'error_display', +) { + type ErrorDisplayWidget = IComboWidget + + const widget = makeComboWidget( + node, + name, + ERROR_DISPLAY_CHOICES, + 'dialog', + () => {}, + 'how to display detected errors', + ) + return widget as ErrorDisplayWidget +} diff --git a/src/ts/widgets/queue.ts b/src/ts/widgets/queue.ts new file mode 100644 index 0000000..835d5f8 --- /dev/null +++ b/src/ts/widgets/queue.ts @@ -0,0 +1,96 @@ +import type { LGraphNode } from '@comfyorg/litegraph' +import type { ComfyApp } from '@comfyorg/comfyui-frontend-types' + +import { api } from '~/.mock/scripts/api.js' +import type { InputSpec } from '~/.d.ts/comfyui-frontend-types_alt.js' + +interface IQueueData { + index: number + total: number +} +interface IQueueMessage { + index: [number] + total: [number] +} +function isQueueMessage(message: unknown): message is IQueueMessage { + const msg = message as IQueueMessage + return ( + Array.isArray(msg.index) && + msg.index.length === 1 && + typeof msg.index[0] === 'number' && + Array.isArray(msg.total) && + msg.total.length === 1 && + typeof msg.total[0] === 'number' + ) +} +function queueMessageToData(message: IQueueMessage): IQueueData { + return { + index: message.index[0], + total: message.total[0], + } +} + +export function QUEUE_STATUS( + node: LGraphNode, + inputName: string, + _inputData: InputSpec, + app: ComfyApp | undefined, // forced to accept undefined as per ComfyWidgetConstructor +) { + if (!app) throw new Error('QUEUE_STATUS: app is undefined') + const widget = node.addWidget('button', inputName, 0, () => {}) + + const reset = () => { + widget.value = 0 + widget.total = undefined + } + + // set initial value + reset() + widget.label = 'Ready' + + // handle page refresh: onConfigure is called after onNodeCreated, after applying serialized values, so we force reset here + const originalOnConfigure = node.onConfigure + node.onConfigure = function () { + originalOnConfigure?.apply(this) + reset() + } + + const originalOnExecuted = node.onExecuted + node.onExecuted = function (message: unknown) { + originalOnExecuted?.apply(this, message) + if (isQueueMessage(message)) { + const data = queueMessageToData(message as IQueueMessage) + if (!widget.total) widget.total = data.total + if (data.index < data.total - 1) { + widget.value = data.index + 1 + widget.label = `Processing: ${widget.value} / ${widget.total}` + app.queuePrompt(0, 1) + } else { + widget.label = `Processing: ${widget.value + 1} / ${widget.total}` + // wait for the execution to end before displaying the "Complete" label; note: the listener will be automatically deleted after use + api.addEventListener( + 'execution_success', + () => { + widget.label = `Complete: ${widget.total} / ${widget.total}` + reset() + }, + { once: true }, + ) + } + } + } + + // handle API interruptions and errors + const original_api_interrupt = api.interrupt + api.interrupt = async function (...args) { + await original_api_interrupt.apply(this, ...args) + widget.label = 'Interrupted' + reset() + } + api.addEventListener('execution_error', () => { + widget.label = 'Error detected' + reset() + }) + + return widget +} diff --git a/static/Roboto-Bold.ttf b/static/Roboto-Bold.ttf new file mode 100644 index 0000000..0458229 Binary files /dev/null and b/static/Roboto-Bold.ttf differ diff --git a/static/Roboto-BoldItalic.ttf b/static/Roboto-BoldItalic.ttf new file mode 100644 index 0000000..ca07299 Binary files /dev/null and b/static/Roboto-BoldItalic.ttf differ diff --git a/static/Roboto-Italic.ttf b/static/Roboto-Italic.ttf new file mode 100644 index 0000000..f5f5538 Binary files /dev/null and b/static/Roboto-Italic.ttf differ diff --git a/static/Roboto-Regular.ttf b/static/Roboto-Regular.ttf new file mode 100644 index 0000000..5e84294 Binary files /dev/null and b/static/Roboto-Regular.ttf differ diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..fca4603 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,29 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "NodeNext", + "lib": ["ES2022", "DOM", "DOM.Iterable"], + "skipLibCheck": true, + + "moduleResolution": "nodenext", + "removeComments": true, + + /* Linting */ + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true, + "noImplicitAny": true, + "strictNullChecks": true, + + "outDir": "./dist/js", + "paths": { + "~/*": ["./src/ts/*"] + } + }, + "include": [ + "src/ts/**/*.ts", + "src/ts/.d.ts/**/*.d.ts", + "src/ts/.mock/**/*.ts" + ] +} diff --git a/tsconfig.prod.json b/tsconfig.prod.json new file mode 100644 index 0000000..4c6cf5c --- /dev/null +++ b/tsconfig.prod.json @@ -0,0 +1,4 @@ +{ + "extends": "./tsconfig", + "exclude": ["**/test/", "**/*.test.ts", "**/*.mock.ts"] +} diff --git a/yarn.lock b/yarn.lock new file mode 100644 index 0000000..f1ff212 --- /dev/null +++ b/yarn.lock @@ -0,0 +1,2232 @@ +# This file is generated by running "yarn install" inside your project. +# Manual changes might be lost - proceed with caution! + +__metadata: + version: 8 + cacheKey: 10c0 + +"@comfyorg/comfyui-frontend-types@npm:^1.6.8": + version: 1.7.10 + resolution: "@comfyorg/comfyui-frontend-types@npm:1.7.10" + dependencies: + "@comfyorg/litegraph": "npm:^0.8.60" + peerDependencies: + vue: ^3.4.31 + zod: ^3.23.8 + checksum: 10c0/92bebd84bf28e4d33d470c4b691b2b126c03a56026d0c7c84e1496d2bc87657e2b34fb5e8c70480083a02e1d0d2c34a6c6d83b563e3ed124c082b3e72e967cfd + languageName: node + linkType: hard + +"@comfyorg/litegraph@npm:^0.8.50, @comfyorg/litegraph@npm:^0.8.60": + version: 0.8.60 + resolution: "@comfyorg/litegraph@npm:0.8.60" + checksum: 10c0/1c1ae4abbd08f23486ffb06a04735e795cb459142432b41496c543d976712cc2681ca59aa81d43439a150f4c4bc2d255ab6b6aeb223830b14dbe191eab921005 + languageName: node + linkType: hard + +"@eslint-community/eslint-utils@npm:^4.2.0, @eslint-community/eslint-utils@npm:^4.4.0": + version: 4.4.1 + resolution: "@eslint-community/eslint-utils@npm:4.4.1" + dependencies: + eslint-visitor-keys: "npm:^3.4.3" + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + checksum: 10c0/2aa0ac2fc50ff3f234408b10900ed4f1a0b19352f21346ad4cc3d83a1271481bdda11097baa45d484dd564c895e0762a27a8240be7a256b3ad47129e96528252 + languageName: node + linkType: hard + +"@eslint-community/regexpp@npm:^4.10.0, @eslint-community/regexpp@npm:^4.12.1": + version: 4.12.1 + resolution: "@eslint-community/regexpp@npm:4.12.1" + checksum: 10c0/a03d98c246bcb9109aec2c08e4d10c8d010256538dcb3f56610191607214523d4fb1b00aa81df830b6dffb74c5fa0be03642513a289c567949d3e550ca11cdf6 + languageName: node + linkType: hard + +"@eslint/config-array@npm:^0.19.0": + version: 0.19.1 + resolution: "@eslint/config-array@npm:0.19.1" + dependencies: + "@eslint/object-schema": "npm:^2.1.5" + debug: "npm:^4.3.1" + minimatch: "npm:^3.1.2" + checksum: 10c0/43b01f596ddad404473beae5cf95c013d29301c72778d0f5bf8a6699939c8a9a5663dbd723b53c5f476b88b0c694f76ea145d1aa9652230d140fe1161e4a4b49 + languageName: node + linkType: hard + +"@eslint/core@npm:^0.10.0": + version: 0.10.0 + resolution: "@eslint/core@npm:0.10.0" + dependencies: + "@types/json-schema": "npm:^7.0.15" + checksum: 10c0/074018075079b3ed1f14fab9d116f11a8824cdfae3e822badf7ad546962fafe717a31e61459bad8cc59cf7070dc413ea9064ddb75c114f05b05921029cde0a64 + languageName: node + linkType: hard + +"@eslint/eslintrc@npm:^3.2.0": + version: 3.2.0 + resolution: "@eslint/eslintrc@npm:3.2.0" + dependencies: + ajv: "npm:^6.12.4" + debug: "npm:^4.3.2" + espree: "npm:^10.0.1" + globals: "npm:^14.0.0" + ignore: "npm:^5.2.0" + import-fresh: "npm:^3.2.1" + js-yaml: "npm:^4.1.0" + minimatch: "npm:^3.1.2" + strip-json-comments: "npm:^3.1.1" + checksum: 10c0/43867a07ff9884d895d9855edba41acf325ef7664a8df41d957135a81a477ff4df4196f5f74dc3382627e5cc8b7ad6b815c2cea1b58f04a75aced7c43414ab8b + languageName: node + linkType: hard + +"@eslint/js@npm:9.18.0, @eslint/js@npm:^9.17.0": + version: 9.18.0 + resolution: "@eslint/js@npm:9.18.0" + checksum: 10c0/3938344c5ac7feef4b73fcb30f3c3e753570cea74c24904bb5d07e9c42fcd34fcbc40f545b081356a299e11f360c9c274b348c05fb0113fc3d492e5175eee140 + languageName: node + linkType: hard + +"@eslint/object-schema@npm:^2.1.5": + version: 2.1.5 + resolution: "@eslint/object-schema@npm:2.1.5" + checksum: 10c0/5320691ed41ecd09a55aff40ce8e56596b4eb81f3d4d6fe530c50fdd6552d88102d1c1a29d970ae798ce30849752a708772de38ded07a6f25b3da32ebea081d8 + languageName: node + linkType: hard + +"@eslint/plugin-kit@npm:^0.2.5": + version: 0.2.5 + resolution: "@eslint/plugin-kit@npm:0.2.5" + dependencies: + "@eslint/core": "npm:^0.10.0" + levn: "npm:^0.4.1" + checksum: 10c0/ba9832b8409af618cf61791805fe201dd62f3c82c783adfcec0f5cd391e68b40beaecb47b9a3209e926dbcab65135f410cae405b69a559197795793399f61176 + languageName: node + linkType: hard + +"@humanfs/core@npm:^0.19.1": + version: 0.19.1 + resolution: "@humanfs/core@npm:0.19.1" + checksum: 10c0/aa4e0152171c07879b458d0e8a704b8c3a89a8c0541726c6b65b81e84fd8b7564b5d6c633feadc6598307d34564bd53294b533491424e8e313d7ab6c7bc5dc67 + languageName: node + linkType: hard + +"@humanfs/node@npm:^0.16.6": + version: 0.16.6 + resolution: "@humanfs/node@npm:0.16.6" + dependencies: + "@humanfs/core": "npm:^0.19.1" + "@humanwhocodes/retry": "npm:^0.3.0" + checksum: 10c0/8356359c9f60108ec204cbd249ecd0356667359b2524886b357617c4a7c3b6aace0fd5a369f63747b926a762a88f8a25bc066fa1778508d110195ce7686243e1 + languageName: node + linkType: hard + +"@humanwhocodes/module-importer@npm:^1.0.1": + version: 1.0.1 + resolution: "@humanwhocodes/module-importer@npm:1.0.1" + checksum: 10c0/909b69c3b86d482c26b3359db16e46a32e0fb30bd306a3c176b8313b9e7313dba0f37f519de6aa8b0a1921349e505f259d19475e123182416a506d7f87e7f529 + languageName: node + linkType: hard + +"@humanwhocodes/retry@npm:^0.3.0": + version: 0.3.1 + resolution: "@humanwhocodes/retry@npm:0.3.1" + checksum: 10c0/f0da1282dfb45e8120480b9e2e275e2ac9bbe1cf016d046fdad8e27cc1285c45bb9e711681237944445157b430093412b4446c1ab3fc4bb037861b5904101d3b + languageName: node + linkType: hard + +"@humanwhocodes/retry@npm:^0.4.1": + version: 0.4.1 + resolution: "@humanwhocodes/retry@npm:0.4.1" + checksum: 10c0/be7bb6841c4c01d0b767d9bb1ec1c9359ee61421ce8ba66c249d035c5acdfd080f32d55a5c9e859cdd7868788b8935774f65b2caf24ec0b7bd7bf333791f063b + languageName: node + linkType: hard + +"@isaacs/cliui@npm:^8.0.2": + version: 8.0.2 + resolution: "@isaacs/cliui@npm:8.0.2" + dependencies: + string-width: "npm:^5.1.2" + string-width-cjs: "npm:string-width@^4.2.0" + strip-ansi: "npm:^7.0.1" + strip-ansi-cjs: "npm:strip-ansi@^6.0.1" + wrap-ansi: "npm:^8.1.0" + wrap-ansi-cjs: "npm:wrap-ansi@^7.0.0" + checksum: 10c0/b1bf42535d49f11dc137f18d5e4e63a28c5569de438a221c369483731e9dac9fb797af554e8bf02b6192d1e5eba6e6402cf93900c3d0ac86391d00d04876789e + languageName: node + linkType: hard + +"@isaacs/fs-minipass@npm:^4.0.0": + version: 4.0.1 + resolution: "@isaacs/fs-minipass@npm:4.0.1" + dependencies: + minipass: "npm:^7.0.4" + checksum: 10c0/c25b6dc1598790d5b55c0947a9b7d111cfa92594db5296c3b907e2f533c033666f692a3939eadac17b1c7c40d362d0b0635dc874cbfe3e70db7c2b07cc97a5d2 + languageName: node + linkType: hard + +"@nodelib/fs.scandir@npm:2.1.5": + version: 2.1.5 + resolution: "@nodelib/fs.scandir@npm:2.1.5" + dependencies: + "@nodelib/fs.stat": "npm:2.0.5" + run-parallel: "npm:^1.1.9" + checksum: 10c0/732c3b6d1b1e967440e65f284bd06e5821fedf10a1bea9ed2bb75956ea1f30e08c44d3def9d6a230666574edbaf136f8cfd319c14fd1f87c66e6a44449afb2eb + languageName: node + linkType: hard + +"@nodelib/fs.stat@npm:2.0.5, @nodelib/fs.stat@npm:^2.0.2": + version: 2.0.5 + resolution: "@nodelib/fs.stat@npm:2.0.5" + checksum: 10c0/88dafe5e3e29a388b07264680dc996c17f4bda48d163a9d4f5c1112979f0ce8ec72aa7116122c350b4e7976bc5566dc3ddb579be1ceaacc727872eb4ed93926d + languageName: node + linkType: hard + +"@nodelib/fs.walk@npm:^1.2.3": + version: 1.2.8 + resolution: "@nodelib/fs.walk@npm:1.2.8" + dependencies: + "@nodelib/fs.scandir": "npm:2.1.5" + fastq: "npm:^1.6.0" + checksum: 10c0/db9de047c3bb9b51f9335a7bb46f4fcfb6829fb628318c12115fbaf7d369bfce71c15b103d1fc3b464812d936220ee9bc1c8f762d032c9f6be9acc99249095b1 + languageName: node + linkType: hard + +"@npmcli/agent@npm:^3.0.0": + version: 3.0.0 + resolution: "@npmcli/agent@npm:3.0.0" + dependencies: + agent-base: "npm:^7.1.0" + http-proxy-agent: "npm:^7.0.0" + https-proxy-agent: "npm:^7.0.1" + lru-cache: "npm:^10.0.1" + socks-proxy-agent: "npm:^8.0.3" + checksum: 10c0/efe37b982f30740ee77696a80c196912c274ecd2cb243bc6ae7053a50c733ce0f6c09fda085145f33ecf453be19654acca74b69e81eaad4c90f00ccffe2f9271 + languageName: node + linkType: hard + +"@npmcli/fs@npm:^4.0.0": + version: 4.0.0 + resolution: "@npmcli/fs@npm:4.0.0" + dependencies: + semver: "npm:^7.3.5" + checksum: 10c0/c90935d5ce670c87b6b14fab04a965a3b8137e585f8b2a6257263bd7f97756dd736cb165bb470e5156a9e718ecd99413dccc54b1138c1a46d6ec7cf325982fe5 + languageName: node + linkType: hard + +"@pkgjs/parseargs@npm:^0.11.0": + version: 0.11.0 + resolution: "@pkgjs/parseargs@npm:0.11.0" + checksum: 10c0/5bd7576bb1b38a47a7fc7b51ac9f38748e772beebc56200450c4a817d712232b8f1d3ef70532c80840243c657d491cf6a6be1e3a214cff907645819fdc34aadd + languageName: node + linkType: hard + +"@pkgr/core@npm:^0.1.0": + version: 0.1.1 + resolution: "@pkgr/core@npm:0.1.1" + checksum: 10c0/3f7536bc7f57320ab2cf96f8973664bef624710c403357429fbf680a5c3b4843c1dbd389bb43daa6b1f6f1f007bb082f5abcb76bb2b5dc9f421647743b71d3d8 + languageName: node + linkType: hard + +"@types/estree@npm:^1.0.6": + version: 1.0.6 + resolution: "@types/estree@npm:1.0.6" + checksum: 10c0/cdfd751f6f9065442cd40957c07fd80361c962869aa853c1c2fd03e101af8b9389d8ff4955a43a6fcfa223dd387a089937f95be0f3eec21ca527039fd2d9859a + languageName: node + linkType: hard + +"@types/json-schema@npm:^7.0.15": + version: 7.0.15 + resolution: "@types/json-schema@npm:7.0.15" + checksum: 10c0/a996a745e6c5d60292f36731dd41341339d4eeed8180bb09226e5c8d23759067692b1d88e5d91d72ee83dfc00d3aca8e7bd43ea120516c17922cbcb7c3e252db + languageName: node + linkType: hard + +"@typescript-eslint/eslint-plugin@npm:8.20.0": + version: 8.20.0 + resolution: "@typescript-eslint/eslint-plugin@npm:8.20.0" + dependencies: + "@eslint-community/regexpp": "npm:^4.10.0" + "@typescript-eslint/scope-manager": "npm:8.20.0" + "@typescript-eslint/type-utils": "npm:8.20.0" + "@typescript-eslint/utils": "npm:8.20.0" + "@typescript-eslint/visitor-keys": "npm:8.20.0" + graphemer: "npm:^1.4.0" + ignore: "npm:^5.3.1" + natural-compare: "npm:^1.4.0" + ts-api-utils: "npm:^2.0.0" + peerDependencies: + "@typescript-eslint/parser": ^8.0.0 || ^8.0.0-alpha.0 + eslint: ^8.57.0 || ^9.0.0 + typescript: ">=4.8.4 <5.8.0" + checksum: 10c0/c68d0dc5419db93c38eea8adecac19e27f8b023d015a944ffded112d584e87fa7fe512070a6a1085899cab2e12e1c8db276e10412b74bf639ca6b04052bbfedc + languageName: node + linkType: hard + +"@typescript-eslint/parser@npm:8.20.0": + version: 8.20.0 + resolution: "@typescript-eslint/parser@npm:8.20.0" + dependencies: + "@typescript-eslint/scope-manager": "npm:8.20.0" + "@typescript-eslint/types": "npm:8.20.0" + "@typescript-eslint/typescript-estree": "npm:8.20.0" + "@typescript-eslint/visitor-keys": "npm:8.20.0" + debug: "npm:^4.3.4" + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: ">=4.8.4 <5.8.0" + checksum: 10c0/fff4a86be27f603ad8d6f7dd9758c46b04a254828f0c6d8a34869c1cf30b5828b60a1dc088f72680a7b65cc5fc696848df4605de19e59a18467306d7ca56c11d + languageName: node + linkType: hard + +"@typescript-eslint/scope-manager@npm:8.20.0": + version: 8.20.0 + resolution: "@typescript-eslint/scope-manager@npm:8.20.0" + dependencies: + "@typescript-eslint/types": "npm:8.20.0" + "@typescript-eslint/visitor-keys": "npm:8.20.0" + checksum: 10c0/a8074768d06c863169294116624a45c19377ff0b8635ad5fa4ae673b43cf704d1b9b79384ceef0ff0abb78b107d345cd90fe5572354daf6ad773fe462ee71e6a + languageName: node + linkType: hard + +"@typescript-eslint/type-utils@npm:8.20.0": + version: 8.20.0 + resolution: "@typescript-eslint/type-utils@npm:8.20.0" + dependencies: + "@typescript-eslint/typescript-estree": "npm:8.20.0" + "@typescript-eslint/utils": "npm:8.20.0" + debug: "npm:^4.3.4" + ts-api-utils: "npm:^2.0.0" + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: ">=4.8.4 <5.8.0" + checksum: 10c0/7d46143f26ec606b71d20f0f5535b16abba2ba7a5a2daecd2584ddb61d1284dd8404f34265cc1fdfd541068b24b0211f7ad94801c94e4c60869d9f26bf3c0b9b + languageName: node + linkType: hard + +"@typescript-eslint/types@npm:8.20.0": + version: 8.20.0 + resolution: "@typescript-eslint/types@npm:8.20.0" + checksum: 10c0/21292d4ca089897015d2bf5ab99909a7b362902f63f4ba10696676823b50d00c7b4cd093b4b43fba01d12bc3feca3852d2c28528c06d8e45446b7477887dbee7 + languageName: node + linkType: hard + +"@typescript-eslint/typescript-estree@npm:8.20.0": + version: 8.20.0 + resolution: "@typescript-eslint/typescript-estree@npm:8.20.0" + dependencies: + "@typescript-eslint/types": "npm:8.20.0" + "@typescript-eslint/visitor-keys": "npm:8.20.0" + debug: "npm:^4.3.4" + fast-glob: "npm:^3.3.2" + is-glob: "npm:^4.0.3" + minimatch: "npm:^9.0.4" + semver: "npm:^7.6.0" + ts-api-utils: "npm:^2.0.0" + peerDependencies: + typescript: ">=4.8.4 <5.8.0" + checksum: 10c0/54a2c1da7d1c5f7e865b941e8a3c98eb4b5f56ed8741664a84065173bde9602cdb8866b0984b26816d6af885c1528311c11e7286e869ed424483b74366514cbd + languageName: node + linkType: hard + +"@typescript-eslint/utils@npm:8.20.0": + version: 8.20.0 + resolution: "@typescript-eslint/utils@npm:8.20.0" + dependencies: + "@eslint-community/eslint-utils": "npm:^4.4.0" + "@typescript-eslint/scope-manager": "npm:8.20.0" + "@typescript-eslint/types": "npm:8.20.0" + "@typescript-eslint/typescript-estree": "npm:8.20.0" + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: ">=4.8.4 <5.8.0" + checksum: 10c0/dd36c3b22a2adde1e1462aed0c8b4720f61859b4ebb0c3ef935a786a6b1cb0ec21eb0689f5a8debe8db26d97ebb979bab68d6f8fe7b0098e6200a485cfe2991b + languageName: node + linkType: hard + +"@typescript-eslint/visitor-keys@npm:8.20.0": + version: 8.20.0 + resolution: "@typescript-eslint/visitor-keys@npm:8.20.0" + dependencies: + "@typescript-eslint/types": "npm:8.20.0" + eslint-visitor-keys: "npm:^4.2.0" + checksum: 10c0/e95d8b2685e8beb6637bf2e9d06e4177a400d3a2b142ba749944690f969ee3186b750082fd9bf34ada82acf1c5dd5970201dfd97619029c8ecca85fb4b50dbd8 + languageName: node + linkType: hard + +"abbrev@npm:^2.0.0": + version: 2.0.0 + resolution: "abbrev@npm:2.0.0" + checksum: 10c0/f742a5a107473946f426c691c08daba61a1d15942616f300b5d32fd735be88fef5cba24201757b6c407fd564555fb48c751cfa33519b2605c8a7aadd22baf372 + languageName: node + linkType: hard + +"acorn-jsx@npm:^5.3.2": + version: 5.3.2 + resolution: "acorn-jsx@npm:5.3.2" + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + checksum: 10c0/4c54868fbef3b8d58927d5e33f0a4de35f59012fe7b12cf9dfbb345fb8f46607709e1c4431be869a23fb63c151033d84c4198fa9f79385cec34fcb1dd53974c1 + languageName: node + linkType: hard + +"acorn@npm:^8.14.0": + version: 8.14.0 + resolution: "acorn@npm:8.14.0" + bin: + acorn: bin/acorn + checksum: 10c0/6d4ee461a7734b2f48836ee0fbb752903606e576cc100eb49340295129ca0b452f3ba91ddd4424a1d4406a98adfb2ebb6bd0ff4c49d7a0930c10e462719bbfd7 + languageName: node + linkType: hard + +"agent-base@npm:^7.1.0, agent-base@npm:^7.1.2": + version: 7.1.3 + resolution: "agent-base@npm:7.1.3" + checksum: 10c0/6192b580c5b1d8fb399b9c62bf8343d76654c2dd62afcb9a52b2cf44a8b6ace1e3b704d3fe3547d91555c857d3df02603341ff2cb961b9cfe2b12f9f3c38ee11 + languageName: node + linkType: hard + +"ajv@npm:^6.12.4": + version: 6.12.6 + resolution: "ajv@npm:6.12.6" + dependencies: + fast-deep-equal: "npm:^3.1.1" + fast-json-stable-stringify: "npm:^2.0.0" + json-schema-traverse: "npm:^0.4.1" + uri-js: "npm:^4.2.2" + checksum: 10c0/41e23642cbe545889245b9d2a45854ebba51cda6c778ebced9649420d9205f2efb39cb43dbc41e358409223b1ea43303ae4839db682c848b891e4811da1a5a71 + languageName: node + linkType: hard + +"ansi-regex@npm:^5.0.1": + version: 5.0.1 + resolution: "ansi-regex@npm:5.0.1" + checksum: 10c0/9a64bb8627b434ba9327b60c027742e5d17ac69277960d041898596271d992d4d52ba7267a63ca10232e29f6107fc8a835f6ce8d719b88c5f8493f8254813737 + languageName: node + linkType: hard + +"ansi-regex@npm:^6.0.1": + version: 6.1.0 + resolution: "ansi-regex@npm:6.1.0" + checksum: 10c0/a91daeddd54746338478eef88af3439a7edf30f8e23196e2d6ed182da9add559c601266dbef01c2efa46a958ad6f1f8b176799657616c702b5b02e799e7fd8dc + languageName: node + linkType: hard + +"ansi-styles@npm:^4.0.0, ansi-styles@npm:^4.1.0": + version: 4.3.0 + resolution: "ansi-styles@npm:4.3.0" + dependencies: + color-convert: "npm:^2.0.1" + checksum: 10c0/895a23929da416f2bd3de7e9cb4eabd340949328ab85ddd6e484a637d8f6820d485f53933446f5291c3b760cbc488beb8e88573dd0f9c7daf83dccc8fe81b041 + languageName: node + linkType: hard + +"ansi-styles@npm:^6.1.0": + version: 6.2.1 + resolution: "ansi-styles@npm:6.2.1" + checksum: 10c0/5d1ec38c123984bcedd996eac680d548f31828bd679a66db2bdf11844634dde55fec3efa9c6bb1d89056a5e79c1ac540c4c784d592ea1d25028a92227d2f2d5c + languageName: node + linkType: hard + +"anymatch@npm:~3.1.2": + version: 3.1.3 + resolution: "anymatch@npm:3.1.3" + dependencies: + normalize-path: "npm:^3.0.0" + picomatch: "npm:^2.0.4" + checksum: 10c0/57b06ae984bc32a0d22592c87384cd88fe4511b1dd7581497831c56d41939c8a001b28e7b853e1450f2bf61992dfcaa8ae2d0d161a0a90c4fb631ef07098fbac + languageName: node + linkType: hard + +"argparse@npm:^2.0.1": + version: 2.0.1 + resolution: "argparse@npm:2.0.1" + checksum: 10c0/c5640c2d89045371c7cedd6a70212a04e360fd34d6edeae32f6952c63949e3525ea77dbec0289d8213a99bbaeab5abfa860b5c12cf88a2e6cf8106e90dd27a7e + languageName: node + linkType: hard + +"array-union@npm:^2.1.0": + version: 2.1.0 + resolution: "array-union@npm:2.1.0" + checksum: 10c0/429897e68110374f39b771ec47a7161fc6a8fc33e196857c0a396dc75df0b5f65e4d046674db764330b6bb66b39ef48dd7c53b6a2ee75cfb0681e0c1a7033962 + languageName: node + linkType: hard + +"balanced-match@npm:^1.0.0": + version: 1.0.2 + resolution: "balanced-match@npm:1.0.2" + checksum: 10c0/9308baf0a7e4838a82bbfd11e01b1cb0f0cf2893bc1676c27c2a8c0e70cbae1c59120c3268517a8ae7fb6376b4639ef81ca22582611dbee4ed28df945134aaee + languageName: node + linkType: hard + +"binary-extensions@npm:^2.0.0": + version: 2.3.0 + resolution: "binary-extensions@npm:2.3.0" + checksum: 10c0/75a59cafc10fb12a11d510e77110c6c7ae3f4ca22463d52487709ca7f18f69d886aa387557cc9864fbdb10153d0bdb4caacabf11541f55e89ed6e18d12ece2b5 + languageName: node + linkType: hard + +"brace-expansion@npm:^1.1.7": + version: 1.1.11 + resolution: "brace-expansion@npm:1.1.11" + dependencies: + balanced-match: "npm:^1.0.0" + concat-map: "npm:0.0.1" + checksum: 10c0/695a56cd058096a7cb71fb09d9d6a7070113c7be516699ed361317aca2ec169f618e28b8af352e02ab4233fb54eb0168460a40dc320bab0034b36ab59aaad668 + languageName: node + linkType: hard + +"brace-expansion@npm:^2.0.1": + version: 2.0.1 + resolution: "brace-expansion@npm:2.0.1" + dependencies: + balanced-match: "npm:^1.0.0" + checksum: 10c0/b358f2fe060e2d7a87aa015979ecea07f3c37d4018f8d6deb5bd4c229ad3a0384fe6029bb76cd8be63c81e516ee52d1a0673edbe2023d53a5191732ae3c3e49f + languageName: node + linkType: hard + +"braces@npm:^3.0.3, braces@npm:~3.0.2": + version: 3.0.3 + resolution: "braces@npm:3.0.3" + dependencies: + fill-range: "npm:^7.1.1" + checksum: 10c0/7c6dfd30c338d2997ba77500539227b9d1f85e388a5f43220865201e407e076783d0881f2d297b9f80951b4c957fcf0b51c1d2d24227631643c3f7c284b0aa04 + languageName: node + linkType: hard + +"cacache@npm:^19.0.1": + version: 19.0.1 + resolution: "cacache@npm:19.0.1" + dependencies: + "@npmcli/fs": "npm:^4.0.0" + fs-minipass: "npm:^3.0.0" + glob: "npm:^10.2.2" + lru-cache: "npm:^10.0.1" + minipass: "npm:^7.0.3" + minipass-collect: "npm:^2.0.1" + minipass-flush: "npm:^1.0.5" + minipass-pipeline: "npm:^1.2.4" + p-map: "npm:^7.0.2" + ssri: "npm:^12.0.0" + tar: "npm:^7.4.3" + unique-filename: "npm:^4.0.0" + checksum: 10c0/01f2134e1bd7d3ab68be851df96c8d63b492b1853b67f2eecb2c37bb682d37cb70bb858a16f2f0554d3c0071be6dfe21456a1ff6fa4b7eed996570d6a25ffe9c + languageName: node + linkType: hard + +"callsites@npm:^3.0.0": + version: 3.1.0 + resolution: "callsites@npm:3.1.0" + checksum: 10c0/fff92277400eb06c3079f9e74f3af120db9f8ea03bad0e84d9aede54bbe2d44a56cccb5f6cf12211f93f52306df87077ecec5b712794c5a9b5dac6d615a3f301 + languageName: node + linkType: hard + +"chalk@npm:^4.0.0": + version: 4.1.2 + resolution: "chalk@npm:4.1.2" + dependencies: + ansi-styles: "npm:^4.1.0" + supports-color: "npm:^7.1.0" + checksum: 10c0/4a3fef5cc34975c898ffe77141450f679721df9dde00f6c304353fa9c8b571929123b26a0e4617bde5018977eb655b31970c297b91b63ee83bb82aeb04666880 + languageName: node + linkType: hard + +"chokidar@npm:^3.5.3": + version: 3.6.0 + resolution: "chokidar@npm:3.6.0" + dependencies: + anymatch: "npm:~3.1.2" + braces: "npm:~3.0.2" + fsevents: "npm:~2.3.2" + glob-parent: "npm:~5.1.2" + is-binary-path: "npm:~2.1.0" + is-glob: "npm:~4.0.1" + normalize-path: "npm:~3.0.0" + readdirp: "npm:~3.6.0" + dependenciesMeta: + fsevents: + optional: true + checksum: 10c0/8361dcd013f2ddbe260eacb1f3cb2f2c6f2b0ad118708a343a5ed8158941a39cb8fb1d272e0f389712e74ee90ce8ba864eece9e0e62b9705cb468a2f6d917462 + languageName: node + linkType: hard + +"chownr@npm:^3.0.0": + version: 3.0.0 + resolution: "chownr@npm:3.0.0" + checksum: 10c0/43925b87700f7e3893296c8e9c56cc58f926411cce3a6e5898136daaf08f08b9a8eb76d37d3267e707d0dcc17aed2e2ebdf5848c0c3ce95cf910a919935c1b10 + languageName: node + linkType: hard + +"color-convert@npm:^2.0.1": + version: 2.0.1 + resolution: "color-convert@npm:2.0.1" + dependencies: + color-name: "npm:~1.1.4" + checksum: 10c0/37e1150172f2e311fe1b2df62c6293a342ee7380da7b9cfdba67ea539909afbd74da27033208d01d6d5cfc65ee7868a22e18d7e7648e004425441c0f8a15a7d7 + languageName: node + linkType: hard + +"color-name@npm:~1.1.4": + version: 1.1.4 + resolution: "color-name@npm:1.1.4" + checksum: 10c0/a1a3f914156960902f46f7f56bc62effc6c94e84b2cae157a526b1c1f74b677a47ec602bf68a61abfa2b42d15b7c5651c6dbe72a43af720bc588dff885b10f95 + languageName: node + linkType: hard + +"commander@npm:^9.0.0": + version: 9.5.0 + resolution: "commander@npm:9.5.0" + checksum: 10c0/5f7784fbda2aaec39e89eb46f06a999e00224b3763dc65976e05929ec486e174fe9aac2655f03ba6a5e83875bd173be5283dc19309b7c65954701c02025b3c1d + languageName: node + linkType: hard + +"concat-map@npm:0.0.1": + version: 0.0.1 + resolution: "concat-map@npm:0.0.1" + checksum: 10c0/c996b1cfdf95b6c90fee4dae37e332c8b6eb7d106430c17d538034c0ad9a1630cb194d2ab37293b1bdd4d779494beee7786d586a50bd9376fd6f7bcc2bd4c98f + languageName: node + linkType: hard + +"confylab-pack@workspace:.": + version: 0.0.0-use.local + resolution: "confylab-pack@workspace:." + dependencies: + "@comfyorg/comfyui-frontend-types": "npm:^1.6.8" + "@comfyorg/litegraph": "npm:^0.8.50" + "@eslint/js": "npm:^9.17.0" + eslint: "npm:^9.17.0" + eslint-config-prettier: "npm:^9.1.0" + eslint-plugin-prettier: "npm:^5.2.1" + globals: "npm:^15.14.0" + prettier: "npm:^3.4.2" + rimraf: "npm:^6.0.1" + tsc-alias: "npm:^1.8.10" + tsc-watch: "npm:6.2.1" + typescript: "npm:^5.7.2" + typescript-eslint: "npm:^8.18.2" + languageName: unknown + linkType: soft + +"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.6": + version: 7.0.6 + resolution: "cross-spawn@npm:7.0.6" + dependencies: + path-key: "npm:^3.1.0" + shebang-command: "npm:^2.0.0" + which: "npm:^2.0.1" + checksum: 10c0/053ea8b2135caff68a9e81470e845613e374e7309a47731e81639de3eaeb90c3d01af0e0b44d2ab9d50b43467223b88567dfeb3262db942dc063b9976718ffc1 + languageName: node + linkType: hard + +"debug@npm:4, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4": + version: 4.4.0 + resolution: "debug@npm:4.4.0" + dependencies: + ms: "npm:^2.1.3" + peerDependenciesMeta: + supports-color: + optional: true + checksum: 10c0/db94f1a182bf886f57b4755f85b3a74c39b5114b9377b7ab375dc2cfa3454f09490cc6c30f829df3fc8042bc8b8995f6567ce5cd96f3bc3688bd24027197d9de + languageName: node + linkType: hard + +"deep-is@npm:^0.1.3": + version: 0.1.4 + resolution: "deep-is@npm:0.1.4" + checksum: 10c0/7f0ee496e0dff14a573dc6127f14c95061b448b87b995fc96c017ce0a1e66af1675e73f1d6064407975bc4ea6ab679497a29fff7b5b9c4e99cb10797c1ad0b4c + languageName: node + linkType: hard + +"dir-glob@npm:^3.0.1": + version: 3.0.1 + resolution: "dir-glob@npm:3.0.1" + dependencies: + path-type: "npm:^4.0.0" + checksum: 10c0/dcac00920a4d503e38bb64001acb19df4efc14536ada475725e12f52c16777afdee4db827f55f13a908ee7efc0cb282e2e3dbaeeb98c0993dd93d1802d3bf00c + languageName: node + linkType: hard + +"duplexer@npm:~0.1.1": + version: 0.1.2 + resolution: "duplexer@npm:0.1.2" + checksum: 10c0/c57bcd4bdf7e623abab2df43a7b5b23d18152154529d166c1e0da6bee341d84c432d157d7e97b32fecb1bf3a8b8857dd85ed81a915789f550637ed25b8e64fc2 + languageName: node + linkType: hard + +"eastasianwidth@npm:^0.2.0": + version: 0.2.0 + resolution: "eastasianwidth@npm:0.2.0" + checksum: 10c0/26f364ebcdb6395f95124fda411f63137a4bfb5d3a06453f7f23dfe52502905bd84e0488172e0f9ec295fdc45f05c23d5d91baf16bd26f0fe9acd777a188dc39 + languageName: node + linkType: hard + +"emoji-regex@npm:^8.0.0": + version: 8.0.0 + resolution: "emoji-regex@npm:8.0.0" + checksum: 10c0/b6053ad39951c4cf338f9092d7bfba448cdfd46fe6a2a034700b149ac9ffbc137e361cbd3c442297f86bed2e5f7576c1b54cc0a6bf8ef5106cc62f496af35010 + languageName: node + linkType: hard + +"emoji-regex@npm:^9.2.2": + version: 9.2.2 + resolution: "emoji-regex@npm:9.2.2" + checksum: 10c0/af014e759a72064cf66e6e694a7fc6b0ed3d8db680427b021a89727689671cefe9d04151b2cad51dbaf85d5ba790d061cd167f1cf32eb7b281f6368b3c181639 + languageName: node + linkType: hard + +"encoding@npm:^0.1.13": + version: 0.1.13 + resolution: "encoding@npm:0.1.13" + dependencies: + iconv-lite: "npm:^0.6.2" + checksum: 10c0/36d938712ff00fe1f4bac88b43bcffb5930c1efa57bbcdca9d67e1d9d6c57cfb1200fb01efe0f3109b2ce99b231f90779532814a81370a1bd3274a0f58585039 + languageName: node + linkType: hard + +"env-paths@npm:^2.2.0": + version: 2.2.1 + resolution: "env-paths@npm:2.2.1" + checksum: 10c0/285325677bf00e30845e330eec32894f5105529db97496ee3f598478e50f008c5352a41a30e5e72ec9de8a542b5a570b85699cd63bd2bc646dbcb9f311d83bc4 + languageName: node + linkType: hard + +"err-code@npm:^2.0.2": + version: 2.0.3 + resolution: "err-code@npm:2.0.3" + checksum: 10c0/b642f7b4dd4a376e954947550a3065a9ece6733ab8e51ad80db727aaae0817c2e99b02a97a3d6cecc648a97848305e728289cf312d09af395403a90c9d4d8a66 + languageName: node + linkType: hard + +"escape-string-regexp@npm:^4.0.0": + version: 4.0.0 + resolution: "escape-string-regexp@npm:4.0.0" + checksum: 10c0/9497d4dd307d845bd7f75180d8188bb17ea8c151c1edbf6b6717c100e104d629dc2dfb687686181b0f4b7d732c7dfdc4d5e7a8ff72de1b0ca283a75bbb3a9cd9 + languageName: node + linkType: hard + +"eslint-config-prettier@npm:^9.1.0": + version: 9.1.0 + resolution: "eslint-config-prettier@npm:9.1.0" + peerDependencies: + eslint: ">=7.0.0" + bin: + eslint-config-prettier: bin/cli.js + checksum: 10c0/6d332694b36bc9ac6fdb18d3ca2f6ac42afa2ad61f0493e89226950a7091e38981b66bac2b47ba39d15b73fff2cd32c78b850a9cf9eed9ca9a96bfb2f3a2f10d + languageName: node + linkType: hard + +"eslint-plugin-prettier@npm:^5.2.1": + version: 5.2.1 + resolution: "eslint-plugin-prettier@npm:5.2.1" + dependencies: + prettier-linter-helpers: "npm:^1.0.0" + synckit: "npm:^0.9.1" + peerDependencies: + "@types/eslint": ">=8.0.0" + eslint: ">=8.0.0" + eslint-config-prettier: "*" + prettier: ">=3.0.0" + peerDependenciesMeta: + "@types/eslint": + optional: true + eslint-config-prettier: + optional: true + checksum: 10c0/4bc8bbaf5bb556c9c501dcdff369137763c49ccaf544f9fa91400360ed5e3a3f1234ab59690e06beca5b1b7e6f6356978cdd3b02af6aba3edea2ffe69ca6e8b2 + languageName: node + linkType: hard + +"eslint-scope@npm:^8.2.0": + version: 8.2.0 + resolution: "eslint-scope@npm:8.2.0" + dependencies: + esrecurse: "npm:^4.3.0" + estraverse: "npm:^5.2.0" + checksum: 10c0/8d2d58e2136d548ac7e0099b1a90d9fab56f990d86eb518de1247a7066d38c908be2f3df477a79cf60d70b30ba18735d6c6e70e9914dca2ee515a729975d70d6 + languageName: node + linkType: hard + +"eslint-visitor-keys@npm:^3.4.3": + version: 3.4.3 + resolution: "eslint-visitor-keys@npm:3.4.3" + checksum: 10c0/92708e882c0a5ffd88c23c0b404ac1628cf20104a108c745f240a13c332a11aac54f49a22d5762efbffc18ecbc9a580d1b7ad034bf5f3cc3307e5cbff2ec9820 + languageName: node + linkType: hard + +"eslint-visitor-keys@npm:^4.2.0": + version: 4.2.0 + resolution: "eslint-visitor-keys@npm:4.2.0" + checksum: 10c0/2ed81c663b147ca6f578312919483eb040295bbab759e5a371953456c636c5b49a559883e2677112453728d66293c0a4c90ab11cab3428cf02a0236d2e738269 + languageName: node + linkType: hard + +"eslint@npm:^9.17.0": + version: 9.18.0 + resolution: "eslint@npm:9.18.0" + dependencies: + "@eslint-community/eslint-utils": "npm:^4.2.0" + "@eslint-community/regexpp": "npm:^4.12.1" + "@eslint/config-array": "npm:^0.19.0" + "@eslint/core": "npm:^0.10.0" + "@eslint/eslintrc": "npm:^3.2.0" + "@eslint/js": "npm:9.18.0" + "@eslint/plugin-kit": "npm:^0.2.5" + "@humanfs/node": "npm:^0.16.6" + "@humanwhocodes/module-importer": "npm:^1.0.1" + "@humanwhocodes/retry": "npm:^0.4.1" + "@types/estree": "npm:^1.0.6" + "@types/json-schema": "npm:^7.0.15" + ajv: "npm:^6.12.4" + chalk: "npm:^4.0.0" + cross-spawn: "npm:^7.0.6" + debug: "npm:^4.3.2" + escape-string-regexp: "npm:^4.0.0" + eslint-scope: "npm:^8.2.0" + eslint-visitor-keys: "npm:^4.2.0" + espree: "npm:^10.3.0" + esquery: "npm:^1.5.0" + esutils: "npm:^2.0.2" + fast-deep-equal: "npm:^3.1.3" + file-entry-cache: "npm:^8.0.0" + find-up: "npm:^5.0.0" + glob-parent: "npm:^6.0.2" + ignore: "npm:^5.2.0" + imurmurhash: "npm:^0.1.4" + is-glob: "npm:^4.0.0" + json-stable-stringify-without-jsonify: "npm:^1.0.1" + lodash.merge: "npm:^4.6.2" + minimatch: "npm:^3.1.2" + natural-compare: "npm:^1.4.0" + optionator: "npm:^0.9.3" + peerDependencies: + jiti: "*" + peerDependenciesMeta: + jiti: + optional: true + bin: + eslint: bin/eslint.js + checksum: 10c0/7f592ad228b9bd627a24870fdc875bacdab7bf535d4b67316c4cb791e90d0125130a74769f3c407b0c4b7027b3082ef33864a63ee1024552a60a17db60493f15 + languageName: node + linkType: hard + +"espree@npm:^10.0.1, espree@npm:^10.3.0": + version: 10.3.0 + resolution: "espree@npm:10.3.0" + dependencies: + acorn: "npm:^8.14.0" + acorn-jsx: "npm:^5.3.2" + eslint-visitor-keys: "npm:^4.2.0" + checksum: 10c0/272beeaca70d0a1a047d61baff64db04664a33d7cfb5d144f84bc8a5c6194c6c8ebe9cc594093ca53add88baa23e59b01e69e8a0160ab32eac570482e165c462 + languageName: node + linkType: hard + +"esquery@npm:^1.5.0": + version: 1.6.0 + resolution: "esquery@npm:1.6.0" + dependencies: + estraverse: "npm:^5.1.0" + checksum: 10c0/cb9065ec605f9da7a76ca6dadb0619dfb611e37a81e318732977d90fab50a256b95fee2d925fba7c2f3f0523aa16f91587246693bc09bc34d5a59575fe6e93d2 + languageName: node + linkType: hard + +"esrecurse@npm:^4.3.0": + version: 4.3.0 + resolution: "esrecurse@npm:4.3.0" + dependencies: + estraverse: "npm:^5.2.0" + checksum: 10c0/81a37116d1408ded88ada45b9fb16dbd26fba3aadc369ce50fcaf82a0bac12772ebd7b24cd7b91fc66786bf2c1ac7b5f196bc990a473efff972f5cb338877cf5 + languageName: node + linkType: hard + +"estraverse@npm:^5.1.0, estraverse@npm:^5.2.0": + version: 5.3.0 + resolution: "estraverse@npm:5.3.0" + checksum: 10c0/1ff9447b96263dec95d6d67431c5e0771eb9776427421260a3e2f0fdd5d6bd4f8e37a7338f5ad2880c9f143450c9b1e4fc2069060724570a49cf9cf0312bd107 + languageName: node + linkType: hard + +"esutils@npm:^2.0.2": + version: 2.0.3 + resolution: "esutils@npm:2.0.3" + checksum: 10c0/9a2fe69a41bfdade834ba7c42de4723c97ec776e40656919c62cbd13607c45e127a003f05f724a1ea55e5029a4cf2de444b13009f2af71271e42d93a637137c7 + languageName: node + linkType: hard + +"event-stream@npm:=3.3.4": + version: 3.3.4 + resolution: "event-stream@npm:3.3.4" + dependencies: + duplexer: "npm:~0.1.1" + from: "npm:~0" + map-stream: "npm:~0.1.0" + pause-stream: "npm:0.0.11" + split: "npm:0.3" + stream-combiner: "npm:~0.0.4" + through: "npm:~2.3.1" + checksum: 10c0/c3ec4e1efc27ab3e73a98923f0a2fa9a19051b87068fea2f3d53d2e4e8c5cfdadf8c8a115b17f3d90b16a46432d396bad91b6e8d0cceb3e449be717a03b75209 + languageName: node + linkType: hard + +"exponential-backoff@npm:^3.1.1": + version: 3.1.1 + resolution: "exponential-backoff@npm:3.1.1" + checksum: 10c0/160456d2d647e6019640bd07111634d8c353038d9fa40176afb7cd49b0548bdae83b56d05e907c2cce2300b81cae35d800ef92fefb9d0208e190fa3b7d6bb579 + languageName: node + linkType: hard + +"fast-deep-equal@npm:^3.1.1, fast-deep-equal@npm:^3.1.3": + version: 3.1.3 + resolution: "fast-deep-equal@npm:3.1.3" + checksum: 10c0/40dedc862eb8992c54579c66d914635afbec43350afbbe991235fdcb4e3a8d5af1b23ae7e79bef7d4882d0ecee06c3197488026998fb19f72dc95acff1d1b1d0 + languageName: node + linkType: hard + +"fast-diff@npm:^1.1.2": + version: 1.3.0 + resolution: "fast-diff@npm:1.3.0" + checksum: 10c0/5c19af237edb5d5effda008c891a18a585f74bf12953be57923f17a3a4d0979565fc64dbc73b9e20926b9d895f5b690c618cbb969af0cf022e3222471220ad29 + languageName: node + linkType: hard + +"fast-glob@npm:^3.2.9, fast-glob@npm:^3.3.2": + version: 3.3.3 + resolution: "fast-glob@npm:3.3.3" + dependencies: + "@nodelib/fs.stat": "npm:^2.0.2" + "@nodelib/fs.walk": "npm:^1.2.3" + glob-parent: "npm:^5.1.2" + merge2: "npm:^1.3.0" + micromatch: "npm:^4.0.8" + checksum: 10c0/f6aaa141d0d3384cf73cbcdfc52f475ed293f6d5b65bfc5def368b09163a9f7e5ec2b3014d80f733c405f58e470ee0cc451c2937685045cddcdeaa24199c43fe + languageName: node + linkType: hard + +"fast-json-stable-stringify@npm:^2.0.0": + version: 2.1.0 + resolution: "fast-json-stable-stringify@npm:2.1.0" + checksum: 10c0/7f081eb0b8a64e0057b3bb03f974b3ef00135fbf36c1c710895cd9300f13c94ba809bb3a81cf4e1b03f6e5285610a61abbd7602d0652de423144dfee5a389c9b + languageName: node + linkType: hard + +"fast-levenshtein@npm:^2.0.6": + version: 2.0.6 + resolution: "fast-levenshtein@npm:2.0.6" + checksum: 10c0/111972b37338bcb88f7d9e2c5907862c280ebf4234433b95bc611e518d192ccb2d38119c4ac86e26b668d75f7f3894f4ff5c4982899afced7ca78633b08287c4 + languageName: node + linkType: hard + +"fastq@npm:^1.6.0": + version: 1.18.0 + resolution: "fastq@npm:1.18.0" + dependencies: + reusify: "npm:^1.0.4" + checksum: 10c0/7be87ecc41762adbddf558d24182f50a4b1a3ef3ee807d33b7623da7aee5faecdcc94fce5aa13fe91df93e269f383232bbcdb2dc5338cd1826503d6063221f36 + languageName: node + linkType: hard + +"file-entry-cache@npm:^8.0.0": + version: 8.0.0 + resolution: "file-entry-cache@npm:8.0.0" + dependencies: + flat-cache: "npm:^4.0.0" + checksum: 10c0/9e2b5938b1cd9b6d7e3612bdc533afd4ac17b2fc646569e9a8abbf2eb48e5eb8e316bc38815a3ef6a1b456f4107f0d0f055a614ca613e75db6bf9ff4d72c1638 + languageName: node + linkType: hard + +"fill-range@npm:^7.1.1": + version: 7.1.1 + resolution: "fill-range@npm:7.1.1" + dependencies: + to-regex-range: "npm:^5.0.1" + checksum: 10c0/b75b691bbe065472f38824f694c2f7449d7f5004aa950426a2c28f0306c60db9b880c0b0e4ed819997ffb882d1da02cfcfc819bddc94d71627f5269682edf018 + languageName: node + linkType: hard + +"find-up@npm:^5.0.0": + version: 5.0.0 + resolution: "find-up@npm:5.0.0" + dependencies: + locate-path: "npm:^6.0.0" + path-exists: "npm:^4.0.0" + checksum: 10c0/062c5a83a9c02f53cdd6d175a37ecf8f87ea5bbff1fdfb828f04bfa021441bc7583e8ebc0872a4c1baab96221fb8a8a275a19809fb93fbc40bd69ec35634069a + languageName: node + linkType: hard + +"flat-cache@npm:^4.0.0": + version: 4.0.1 + resolution: "flat-cache@npm:4.0.1" + dependencies: + flatted: "npm:^3.2.9" + keyv: "npm:^4.5.4" + checksum: 10c0/2c59d93e9faa2523e4fda6b4ada749bed432cfa28c8e251f33b25795e426a1c6dbada777afb1f74fcfff33934fdbdea921ee738fcc33e71adc9d6eca984a1cfc + languageName: node + linkType: hard + +"flatted@npm:^3.2.9": + version: 3.3.2 + resolution: "flatted@npm:3.3.2" + checksum: 10c0/24cc735e74d593b6c767fe04f2ef369abe15b62f6906158079b9874bdb3ee5ae7110bb75042e70cd3f99d409d766f357caf78d5ecee9780206f5fdc5edbad334 + languageName: node + linkType: hard + +"foreground-child@npm:^3.1.0": + version: 3.3.0 + resolution: "foreground-child@npm:3.3.0" + dependencies: + cross-spawn: "npm:^7.0.0" + signal-exit: "npm:^4.0.1" + checksum: 10c0/028f1d41000553fcfa6c4bb5c372963bf3d9bf0b1f25a87d1a6253014343fb69dfb1b42d9625d7cf44c8ba429940f3d0ff718b62105d4d4a4f6ef8ca0a53faa2 + languageName: node + linkType: hard + +"from@npm:~0": + version: 0.1.7 + resolution: "from@npm:0.1.7" + checksum: 10c0/3aab5aea8fe8e1f12a5dee7f390d46a93431ce691b6222dcd5701c5d34378e51ca59b44967da1105a0f90fcdf5d7629d963d51e7ccd79827d19693bdcfb688d4 + languageName: node + linkType: hard + +"fs-minipass@npm:^3.0.0": + version: 3.0.3 + resolution: "fs-minipass@npm:3.0.3" + dependencies: + minipass: "npm:^7.0.3" + checksum: 10c0/63e80da2ff9b621e2cb1596abcb9207f1cf82b968b116ccd7b959e3323144cce7fb141462200971c38bbf2ecca51695069db45265705bed09a7cd93ae5b89f94 + languageName: node + linkType: hard + +"fsevents@npm:~2.3.2": + version: 2.3.3 + resolution: "fsevents@npm:2.3.3" + dependencies: + node-gyp: "npm:latest" + checksum: 10c0/a1f0c44595123ed717febbc478aa952e47adfc28e2092be66b8ab1635147254ca6cfe1df792a8997f22716d4cbafc73309899ff7bfac2ac3ad8cf2e4ecc3ec60 + conditions: os=darwin + languageName: node + linkType: hard + +"fsevents@patch:fsevents@npm%3A~2.3.2#optional!builtin": + version: 2.3.3 + resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin::version=2.3.3&hash=df0bf1" + dependencies: + node-gyp: "npm:latest" + conditions: os=darwin + languageName: node + linkType: hard + +"glob-parent@npm:^5.1.2, glob-parent@npm:~5.1.2": + version: 5.1.2 + resolution: "glob-parent@npm:5.1.2" + dependencies: + is-glob: "npm:^4.0.1" + checksum: 10c0/cab87638e2112bee3f839ef5f6e0765057163d39c66be8ec1602f3823da4692297ad4e972de876ea17c44d652978638d2fd583c6713d0eb6591706825020c9ee + languageName: node + linkType: hard + +"glob-parent@npm:^6.0.2": + version: 6.0.2 + resolution: "glob-parent@npm:6.0.2" + dependencies: + is-glob: "npm:^4.0.3" + checksum: 10c0/317034d88654730230b3f43bb7ad4f7c90257a426e872ea0bf157473ac61c99bf5d205fad8f0185f989be8d2fa6d3c7dce1645d99d545b6ea9089c39f838e7f8 + languageName: node + linkType: hard + +"glob@npm:^10.2.2, glob@npm:^10.3.10, glob@npm:^10.3.7": + version: 10.4.5 + resolution: "glob@npm:10.4.5" + dependencies: + foreground-child: "npm:^3.1.0" + jackspeak: "npm:^3.1.2" + minimatch: "npm:^9.0.4" + minipass: "npm:^7.1.2" + package-json-from-dist: "npm:^1.0.0" + path-scurry: "npm:^1.11.1" + bin: + glob: dist/esm/bin.mjs + checksum: 10c0/19a9759ea77b8e3ca0a43c2f07ecddc2ad46216b786bb8f993c445aee80d345925a21e5280c7b7c6c59e860a0154b84e4b2b60321fea92cd3c56b4a7489f160e + languageName: node + linkType: hard + +"glob@npm:^11.0.0": + version: 11.0.1 + resolution: "glob@npm:11.0.1" + dependencies: + foreground-child: "npm:^3.1.0" + jackspeak: "npm:^4.0.1" + minimatch: "npm:^10.0.0" + minipass: "npm:^7.1.2" + package-json-from-dist: "npm:^1.0.0" + path-scurry: "npm:^2.0.0" + bin: + glob: dist/esm/bin.mjs + checksum: 10c0/2b32588be52e9e90f914c7d8dec32f3144b81b84054b0f70e9adfebf37cd7014570489f2a79d21f7801b9a4bd4cca94f426966bfd00fb64a5b705cfe10da3a03 + languageName: node + linkType: hard + +"globals@npm:^14.0.0": + version: 14.0.0 + resolution: "globals@npm:14.0.0" + checksum: 10c0/b96ff42620c9231ad468d4c58ff42afee7777ee1c963013ff8aabe095a451d0ceeb8dcd8ef4cbd64d2538cef45f787a78ba3a9574f4a634438963e334471302d + languageName: node + linkType: hard + +"globals@npm:^15.14.0": + version: 15.14.0 + resolution: "globals@npm:15.14.0" + checksum: 10c0/039deb8648bd373b7940c15df9f96ab7508fe92b31bbd39cbd1c1a740bd26db12457aa3e5d211553b234f30e9b1db2fee3683012f543a01a6942c9062857facb + languageName: node + linkType: hard + +"globby@npm:^11.0.4": + version: 11.1.0 + resolution: "globby@npm:11.1.0" + dependencies: + array-union: "npm:^2.1.0" + dir-glob: "npm:^3.0.1" + fast-glob: "npm:^3.2.9" + ignore: "npm:^5.2.0" + merge2: "npm:^1.4.1" + slash: "npm:^3.0.0" + checksum: 10c0/b39511b4afe4bd8a7aead3a27c4ade2b9968649abab0a6c28b1a90141b96ca68ca5db1302f7c7bd29eab66bf51e13916b8e0a3d0ac08f75e1e84a39b35691189 + languageName: node + linkType: hard + +"graceful-fs@npm:^4.2.6": + version: 4.2.11 + resolution: "graceful-fs@npm:4.2.11" + checksum: 10c0/386d011a553e02bc594ac2ca0bd6d9e4c22d7fa8cfbfc448a6d148c59ea881b092db9dbe3547ae4b88e55f1b01f7c4a2ecc53b310c042793e63aa44cf6c257f2 + languageName: node + linkType: hard + +"graphemer@npm:^1.4.0": + version: 1.4.0 + resolution: "graphemer@npm:1.4.0" + checksum: 10c0/e951259d8cd2e0d196c72ec711add7115d42eb9a8146c8eeda5b8d3ac91e5dd816b9cd68920726d9fd4490368e7ed86e9c423f40db87e2d8dfafa00fa17c3a31 + languageName: node + linkType: hard + +"has-flag@npm:^4.0.0": + version: 4.0.0 + resolution: "has-flag@npm:4.0.0" + checksum: 10c0/2e789c61b7888d66993e14e8331449e525ef42aac53c627cc53d1c3334e768bcb6abdc4f5f0de1478a25beec6f0bd62c7549058b7ac53e924040d4f301f02fd1 + languageName: node + linkType: hard + +"http-cache-semantics@npm:^4.1.1": + version: 4.1.1 + resolution: "http-cache-semantics@npm:4.1.1" + checksum: 10c0/ce1319b8a382eb3cbb4a37c19f6bfe14e5bb5be3d09079e885e8c513ab2d3cd9214902f8a31c9dc4e37022633ceabfc2d697405deeaf1b8f3552bb4ed996fdfc + languageName: node + linkType: hard + +"http-proxy-agent@npm:^7.0.0": + version: 7.0.2 + resolution: "http-proxy-agent@npm:7.0.2" + dependencies: + agent-base: "npm:^7.1.0" + debug: "npm:^4.3.4" + checksum: 10c0/4207b06a4580fb85dd6dff521f0abf6db517489e70863dca1a0291daa7f2d3d2d6015a57bd702af068ea5cf9f1f6ff72314f5f5b4228d299c0904135d2aef921 + languageName: node + linkType: hard + +"https-proxy-agent@npm:^7.0.1": + version: 7.0.6 + resolution: "https-proxy-agent@npm:7.0.6" + dependencies: + agent-base: "npm:^7.1.2" + debug: "npm:4" + checksum: 10c0/f729219bc735edb621fa30e6e84e60ee5d00802b8247aac0d7b79b0bd6d4b3294737a337b93b86a0bd9e68099d031858a39260c976dc14cdbba238ba1f8779ac + languageName: node + linkType: hard + +"iconv-lite@npm:^0.6.2": + version: 0.6.3 + resolution: "iconv-lite@npm:0.6.3" + dependencies: + safer-buffer: "npm:>= 2.1.2 < 3.0.0" + checksum: 10c0/98102bc66b33fcf5ac044099d1257ba0b7ad5e3ccd3221f34dd508ab4070edff183276221684e1e0555b145fce0850c9f7d2b60a9fcac50fbb4ea0d6e845a3b1 + languageName: node + linkType: hard + +"ignore@npm:^5.2.0, ignore@npm:^5.3.1": + version: 5.3.2 + resolution: "ignore@npm:5.3.2" + checksum: 10c0/f9f652c957983634ded1e7f02da3b559a0d4cc210fca3792cb67f1b153623c9c42efdc1c4121af171e295444459fc4a9201101fb041b1104a3c000bccb188337 + languageName: node + linkType: hard + +"import-fresh@npm:^3.2.1": + version: 3.3.0 + resolution: "import-fresh@npm:3.3.0" + dependencies: + parent-module: "npm:^1.0.0" + resolve-from: "npm:^4.0.0" + checksum: 10c0/7f882953aa6b740d1f0e384d0547158bc86efbf2eea0f1483b8900a6f65c5a5123c2cf09b0d542cc419d0b98a759ecaeb394237e97ea427f2da221dc3cd80cc3 + languageName: node + linkType: hard + +"imurmurhash@npm:^0.1.4": + version: 0.1.4 + resolution: "imurmurhash@npm:0.1.4" + checksum: 10c0/8b51313850dd33605c6c9d3fd9638b714f4c4c40250cff658209f30d40da60f78992fb2df5dabee4acf589a6a82bbc79ad5486550754bd9ec4e3fc0d4a57d6a6 + languageName: node + linkType: hard + +"ip-address@npm:^9.0.5": + version: 9.0.5 + resolution: "ip-address@npm:9.0.5" + dependencies: + jsbn: "npm:1.1.0" + sprintf-js: "npm:^1.1.3" + checksum: 10c0/331cd07fafcb3b24100613e4b53e1a2b4feab11e671e655d46dc09ee233da5011284d09ca40c4ecbdfe1d0004f462958675c224a804259f2f78d2465a87824bc + languageName: node + linkType: hard + +"is-binary-path@npm:~2.1.0": + version: 2.1.0 + resolution: "is-binary-path@npm:2.1.0" + dependencies: + binary-extensions: "npm:^2.0.0" + checksum: 10c0/a16eaee59ae2b315ba36fad5c5dcaf8e49c3e27318f8ab8fa3cdb8772bf559c8d1ba750a589c2ccb096113bb64497084361a25960899cb6172a6925ab6123d38 + languageName: node + linkType: hard + +"is-extglob@npm:^2.1.1": + version: 2.1.1 + resolution: "is-extglob@npm:2.1.1" + checksum: 10c0/5487da35691fbc339700bbb2730430b07777a3c21b9ebaecb3072512dfd7b4ba78ac2381a87e8d78d20ea08affb3f1971b4af629173a6bf435ff8a4c47747912 + languageName: node + linkType: hard + +"is-fullwidth-code-point@npm:^3.0.0": + version: 3.0.0 + resolution: "is-fullwidth-code-point@npm:3.0.0" + checksum: 10c0/bb11d825e049f38e04c06373a8d72782eee0205bda9d908cc550ccb3c59b99d750ff9537982e01733c1c94a58e35400661f57042158ff5e8f3e90cf936daf0fc + languageName: node + linkType: hard + +"is-glob@npm:^4.0.0, is-glob@npm:^4.0.1, is-glob@npm:^4.0.3, is-glob@npm:~4.0.1": + version: 4.0.3 + resolution: "is-glob@npm:4.0.3" + dependencies: + is-extglob: "npm:^2.1.1" + checksum: 10c0/17fb4014e22be3bbecea9b2e3a76e9e34ff645466be702f1693e8f1ee1adac84710d0be0bd9f967d6354036fd51ab7c2741d954d6e91dae6bb69714de92c197a + languageName: node + linkType: hard + +"is-number@npm:^7.0.0": + version: 7.0.0 + resolution: "is-number@npm:7.0.0" + checksum: 10c0/b4686d0d3053146095ccd45346461bc8e53b80aeb7671cc52a4de02dbbf7dc0d1d2a986e2fe4ae206984b4d34ef37e8b795ebc4f4295c978373e6575e295d811 + languageName: node + linkType: hard + +"isexe@npm:^2.0.0": + version: 2.0.0 + resolution: "isexe@npm:2.0.0" + checksum: 10c0/228cfa503fadc2c31596ab06ed6aa82c9976eec2bfd83397e7eaf06d0ccf42cd1dfd6743bf9aeb01aebd4156d009994c5f76ea898d2832c1fe342da923ca457d + languageName: node + linkType: hard + +"isexe@npm:^3.1.1": + version: 3.1.1 + resolution: "isexe@npm:3.1.1" + checksum: 10c0/9ec257654093443eb0a528a9c8cbba9c0ca7616ccb40abd6dde7202734d96bb86e4ac0d764f0f8cd965856aacbff2f4ce23e730dc19dfb41e3b0d865ca6fdcc7 + languageName: node + linkType: hard + +"jackspeak@npm:^3.1.2": + version: 3.4.3 + resolution: "jackspeak@npm:3.4.3" + dependencies: + "@isaacs/cliui": "npm:^8.0.2" + "@pkgjs/parseargs": "npm:^0.11.0" + dependenciesMeta: + "@pkgjs/parseargs": + optional: true + checksum: 10c0/6acc10d139eaefdbe04d2f679e6191b3abf073f111edf10b1de5302c97ec93fffeb2fdd8681ed17f16268aa9dd4f8c588ed9d1d3bffbbfa6e8bf897cbb3149b9 + languageName: node + linkType: hard + +"jackspeak@npm:^4.0.1": + version: 4.0.2 + resolution: "jackspeak@npm:4.0.2" + dependencies: + "@isaacs/cliui": "npm:^8.0.2" + checksum: 10c0/b26039d11c0163a95b1e58851b9ac453cce64ad6d1eb98a00b303ad5eeb761b29d33c9419d1e16c016d3f7151c8edf7df223e6cf93a1907655fd95d6ce85c0de + languageName: node + linkType: hard + +"js-yaml@npm:^4.1.0": + version: 4.1.0 + resolution: "js-yaml@npm:4.1.0" + dependencies: + argparse: "npm:^2.0.1" + bin: + js-yaml: bin/js-yaml.js + checksum: 10c0/184a24b4eaacfce40ad9074c64fd42ac83cf74d8c8cd137718d456ced75051229e5061b8633c3366b8aada17945a7a356b337828c19da92b51ae62126575018f + languageName: node + linkType: hard + +"jsbn@npm:1.1.0": + version: 1.1.0 + resolution: "jsbn@npm:1.1.0" + checksum: 10c0/4f907fb78d7b712e11dea8c165fe0921f81a657d3443dde75359ed52eb2b5d33ce6773d97985a089f09a65edd80b11cb75c767b57ba47391fee4c969f7215c96 + languageName: node + linkType: hard + +"json-buffer@npm:3.0.1": + version: 3.0.1 + resolution: "json-buffer@npm:3.0.1" + checksum: 10c0/0d1c91569d9588e7eef2b49b59851f297f3ab93c7b35c7c221e288099322be6b562767d11e4821da500f3219542b9afd2e54c5dc573107c1126ed1080f8e96d7 + languageName: node + linkType: hard + +"json-schema-traverse@npm:^0.4.1": + version: 0.4.1 + resolution: "json-schema-traverse@npm:0.4.1" + checksum: 10c0/108fa90d4cc6f08243aedc6da16c408daf81793bf903e9fd5ab21983cda433d5d2da49e40711da016289465ec2e62e0324dcdfbc06275a607fe3233fde4942ce + languageName: node + linkType: hard + +"json-stable-stringify-without-jsonify@npm:^1.0.1": + version: 1.0.1 + resolution: "json-stable-stringify-without-jsonify@npm:1.0.1" + checksum: 10c0/cb168b61fd4de83e58d09aaa6425ef71001bae30d260e2c57e7d09a5fd82223e2f22a042dedaab8db23b7d9ae46854b08bb1f91675a8be11c5cffebef5fb66a5 + languageName: node + linkType: hard + +"keyv@npm:^4.5.4": + version: 4.5.4 + resolution: "keyv@npm:4.5.4" + dependencies: + json-buffer: "npm:3.0.1" + checksum: 10c0/aa52f3c5e18e16bb6324876bb8b59dd02acf782a4b789c7b2ae21107fab95fab3890ed448d4f8dba80ce05391eeac4bfabb4f02a20221342982f806fa2cf271e + languageName: node + linkType: hard + +"levn@npm:^0.4.1": + version: 0.4.1 + resolution: "levn@npm:0.4.1" + dependencies: + prelude-ls: "npm:^1.2.1" + type-check: "npm:~0.4.0" + checksum: 10c0/effb03cad7c89dfa5bd4f6989364bfc79994c2042ec5966cb9b95990e2edee5cd8969ddf42616a0373ac49fac1403437deaf6e9050fbbaa3546093a59b9ac94e + languageName: node + linkType: hard + +"locate-path@npm:^6.0.0": + version: 6.0.0 + resolution: "locate-path@npm:6.0.0" + dependencies: + p-locate: "npm:^5.0.0" + checksum: 10c0/d3972ab70dfe58ce620e64265f90162d247e87159b6126b01314dd67be43d50e96a50b517bce2d9452a79409c7614054c277b5232377de50416564a77ac7aad3 + languageName: node + linkType: hard + +"lodash.merge@npm:^4.6.2": + version: 4.6.2 + resolution: "lodash.merge@npm:4.6.2" + checksum: 10c0/402fa16a1edd7538de5b5903a90228aa48eb5533986ba7fa26606a49db2572bf414ff73a2c9f5d5fd36b31c46a5d5c7e1527749c07cbcf965ccff5fbdf32c506 + languageName: node + linkType: hard + +"lru-cache@npm:^10.0.1, lru-cache@npm:^10.2.0": + version: 10.4.3 + resolution: "lru-cache@npm:10.4.3" + checksum: 10c0/ebd04fbca961e6c1d6c0af3799adcc966a1babe798f685bb84e6599266599cd95d94630b10262f5424539bc4640107e8a33aa28585374abf561d30d16f4b39fb + languageName: node + linkType: hard + +"lru-cache@npm:^11.0.0": + version: 11.0.2 + resolution: "lru-cache@npm:11.0.2" + checksum: 10c0/c993b8e06ead0b24b969c1dbb5b301716aed66e320e9014a80012f5febe280b438f28ff50046b2c55ff404e889351ccb332ff91f8dd175a21f5eae80e3fb155f + languageName: node + linkType: hard + +"make-fetch-happen@npm:^14.0.3": + version: 14.0.3 + resolution: "make-fetch-happen@npm:14.0.3" + dependencies: + "@npmcli/agent": "npm:^3.0.0" + cacache: "npm:^19.0.1" + http-cache-semantics: "npm:^4.1.1" + minipass: "npm:^7.0.2" + minipass-fetch: "npm:^4.0.0" + minipass-flush: "npm:^1.0.5" + minipass-pipeline: "npm:^1.2.4" + negotiator: "npm:^1.0.0" + proc-log: "npm:^5.0.0" + promise-retry: "npm:^2.0.1" + ssri: "npm:^12.0.0" + checksum: 10c0/c40efb5e5296e7feb8e37155bde8eb70bc57d731b1f7d90e35a092fde403d7697c56fb49334d92d330d6f1ca29a98142036d6480a12681133a0a1453164cb2f0 + languageName: node + linkType: hard + +"map-stream@npm:~0.1.0": + version: 0.1.0 + resolution: "map-stream@npm:0.1.0" + checksum: 10c0/7dd6debe511c1b55d9da75e1efa65a28b1252a2d8357938d2e49b412713c478efbaefb0cdf0ee0533540c3bf733e8f9f71e1a15aa0fe74bf71b64e75bf1576bd + languageName: node + linkType: hard + +"merge2@npm:^1.3.0, merge2@npm:^1.4.1": + version: 1.4.1 + resolution: "merge2@npm:1.4.1" + checksum: 10c0/254a8a4605b58f450308fc474c82ac9a094848081bf4c06778200207820e5193726dc563a0d2c16468810516a5c97d9d3ea0ca6585d23c58ccfff2403e8dbbeb + languageName: node + linkType: hard + +"micromatch@npm:^4.0.8": + version: 4.0.8 + resolution: "micromatch@npm:4.0.8" + dependencies: + braces: "npm:^3.0.3" + picomatch: "npm:^2.3.1" + checksum: 10c0/166fa6eb926b9553f32ef81f5f531d27b4ce7da60e5baf8c021d043b27a388fb95e46a8038d5045877881e673f8134122b59624d5cecbd16eb50a42e7a6b5ca8 + languageName: node + linkType: hard + +"minimatch@npm:^10.0.0": + version: 10.0.1 + resolution: "minimatch@npm:10.0.1" + dependencies: + brace-expansion: "npm:^2.0.1" + checksum: 10c0/e6c29a81fe83e1877ad51348306be2e8aeca18c88fdee7a99df44322314279e15799e41d7cb274e4e8bb0b451a3bc622d6182e157dfa1717d6cda75e9cd8cd5d + languageName: node + linkType: hard + +"minimatch@npm:^3.1.2": + version: 3.1.2 + resolution: "minimatch@npm:3.1.2" + dependencies: + brace-expansion: "npm:^1.1.7" + checksum: 10c0/0262810a8fc2e72cca45d6fd86bd349eee435eb95ac6aa45c9ea2180e7ee875ef44c32b55b5973ceabe95ea12682f6e3725cbb63d7a2d1da3ae1163c8b210311 + languageName: node + linkType: hard + +"minimatch@npm:^9.0.4": + version: 9.0.5 + resolution: "minimatch@npm:9.0.5" + dependencies: + brace-expansion: "npm:^2.0.1" + checksum: 10c0/de96cf5e35bdf0eab3e2c853522f98ffbe9a36c37797778d2665231ec1f20a9447a7e567cb640901f89e4daaa95ae5d70c65a9e8aa2bb0019b6facbc3c0575ed + languageName: node + linkType: hard + +"minipass-collect@npm:^2.0.1": + version: 2.0.1 + resolution: "minipass-collect@npm:2.0.1" + dependencies: + minipass: "npm:^7.0.3" + checksum: 10c0/5167e73f62bb74cc5019594709c77e6a742051a647fe9499abf03c71dca75515b7959d67a764bdc4f8b361cf897fbf25e2d9869ee039203ed45240f48b9aa06e + languageName: node + linkType: hard + +"minipass-fetch@npm:^4.0.0": + version: 4.0.0 + resolution: "minipass-fetch@npm:4.0.0" + dependencies: + encoding: "npm:^0.1.13" + minipass: "npm:^7.0.3" + minipass-sized: "npm:^1.0.3" + minizlib: "npm:^3.0.1" + dependenciesMeta: + encoding: + optional: true + checksum: 10c0/7fa30ce7c373fb6f94c086b374fff1589fd7e78451855d2d06c2e2d9df936d131e73e952163063016592ed3081444bd8d1ea608533313b0149156ce23311da4b + languageName: node + linkType: hard + +"minipass-flush@npm:^1.0.5": + version: 1.0.5 + resolution: "minipass-flush@npm:1.0.5" + dependencies: + minipass: "npm:^3.0.0" + checksum: 10c0/2a51b63feb799d2bb34669205eee7c0eaf9dce01883261a5b77410c9408aa447e478efd191b4de6fc1101e796ff5892f8443ef20d9544385819093dbb32d36bd + languageName: node + linkType: hard + +"minipass-pipeline@npm:^1.2.4": + version: 1.2.4 + resolution: "minipass-pipeline@npm:1.2.4" + dependencies: + minipass: "npm:^3.0.0" + checksum: 10c0/cbda57cea20b140b797505dc2cac71581a70b3247b84480c1fed5ca5ba46c25ecc25f68bfc9e6dcb1a6e9017dab5c7ada5eab73ad4f0a49d84e35093e0c643f2 + languageName: node + linkType: hard + +"minipass-sized@npm:^1.0.3": + version: 1.0.3 + resolution: "minipass-sized@npm:1.0.3" + dependencies: + minipass: "npm:^3.0.0" + checksum: 10c0/298f124753efdc745cfe0f2bdfdd81ba25b9f4e753ca4a2066eb17c821f25d48acea607dfc997633ee5bf7b6dfffb4eee4f2051eb168663f0b99fad2fa4829cb + languageName: node + linkType: hard + +"minipass@npm:^3.0.0": + version: 3.3.6 + resolution: "minipass@npm:3.3.6" + dependencies: + yallist: "npm:^4.0.0" + checksum: 10c0/a114746943afa1dbbca8249e706d1d38b85ed1298b530f5808ce51f8e9e941962e2a5ad2e00eae7dd21d8a4aae6586a66d4216d1a259385e9d0358f0c1eba16c + languageName: node + linkType: hard + +"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.0.4, minipass@npm:^7.1.2": + version: 7.1.2 + resolution: "minipass@npm:7.1.2" + checksum: 10c0/b0fd20bb9fb56e5fa9a8bfac539e8915ae07430a619e4b86ff71f5fc757ef3924b23b2c4230393af1eda647ed3d75739e4e0acb250a6b1eb277cf7f8fe449557 + languageName: node + linkType: hard + +"minizlib@npm:^3.0.1": + version: 3.0.1 + resolution: "minizlib@npm:3.0.1" + dependencies: + minipass: "npm:^7.0.4" + rimraf: "npm:^5.0.5" + checksum: 10c0/82f8bf70da8af656909a8ee299d7ed3b3372636749d29e105f97f20e88971be31f5ed7642f2e898f00283b68b701cc01307401cdc209b0efc5dd3818220e5093 + languageName: node + linkType: hard + +"mkdirp@npm:^3.0.1": + version: 3.0.1 + resolution: "mkdirp@npm:3.0.1" + bin: + mkdirp: dist/cjs/src/bin.js + checksum: 10c0/9f2b975e9246351f5e3a40dcfac99fcd0baa31fbfab615fe059fb11e51f10e4803c63de1f384c54d656e4db31d000e4767e9ef076a22e12a641357602e31d57d + languageName: node + linkType: hard + +"ms@npm:^2.1.3": + version: 2.1.3 + resolution: "ms@npm:2.1.3" + checksum: 10c0/d924b57e7312b3b63ad21fc5b3dc0af5e78d61a1fc7cfb5457edaf26326bf62be5307cc87ffb6862ef1c2b33b0233cdb5d4f01c4c958cc0d660948b65a287a48 + languageName: node + linkType: hard + +"mylas@npm:^2.1.9": + version: 2.1.13 + resolution: "mylas@npm:2.1.13" + checksum: 10c0/093dfaf88f444d9da956c68a61ddcfe05ab9411c0024b0c7f4d721639ba7d311ea8f9c052ce617344e67d40982f67614cd634b525b923048bf9a191234968c9c + languageName: node + linkType: hard + +"natural-compare@npm:^1.4.0": + version: 1.4.0 + resolution: "natural-compare@npm:1.4.0" + checksum: 10c0/f5f9a7974bfb28a91afafa254b197f0f22c684d4a1731763dda960d2c8e375b36c7d690e0d9dc8fba774c537af14a7e979129bca23d88d052fbeb9466955e447 + languageName: node + linkType: hard + +"negotiator@npm:^1.0.0": + version: 1.0.0 + resolution: "negotiator@npm:1.0.0" + checksum: 10c0/4c559dd52669ea48e1914f9d634227c561221dd54734070791f999c52ed0ff36e437b2e07d5c1f6e32909fc625fe46491c16e4a8f0572567d4dd15c3a4fda04b + languageName: node + linkType: hard + +"node-cleanup@npm:^2.1.2": + version: 2.1.2 + resolution: "node-cleanup@npm:2.1.2" + checksum: 10c0/c59077d7cac01f6315e4417e5d13523e43aa19965b14768581dbd06b37419323abe5f7171afe6aa52b7a483bdd0027e5a5f62a532a2ebec2a8c4cdf163736c92 + languageName: node + linkType: hard + +"node-gyp@npm:latest": + version: 11.0.0 + resolution: "node-gyp@npm:11.0.0" + dependencies: + env-paths: "npm:^2.2.0" + exponential-backoff: "npm:^3.1.1" + glob: "npm:^10.3.10" + graceful-fs: "npm:^4.2.6" + make-fetch-happen: "npm:^14.0.3" + nopt: "npm:^8.0.0" + proc-log: "npm:^5.0.0" + semver: "npm:^7.3.5" + tar: "npm:^7.4.3" + which: "npm:^5.0.0" + bin: + node-gyp: bin/node-gyp.js + checksum: 10c0/a3b885bbee2d271f1def32ba2e30ffcf4562a3db33af06b8b365e053153e2dd2051b9945783c3c8e852d26a0f20f65b251c7e83361623383a99635c0280ee573 + languageName: node + linkType: hard + +"nopt@npm:^8.0.0": + version: 8.0.0 + resolution: "nopt@npm:8.0.0" + dependencies: + abbrev: "npm:^2.0.0" + bin: + nopt: bin/nopt.js + checksum: 10c0/19cb986f79abaca2d0f0b560021da7b32ee6fcc3de48f3eaeb0c324d36755c17754f886a754c091f01f740c17caf7d6aea8237b7fbaf39f476ae5e30a249f18f + languageName: node + linkType: hard + +"normalize-path@npm:^3.0.0, normalize-path@npm:~3.0.0": + version: 3.0.0 + resolution: "normalize-path@npm:3.0.0" + checksum: 10c0/e008c8142bcc335b5e38cf0d63cfd39d6cf2d97480af9abdbe9a439221fd4d749763bab492a8ee708ce7a194bb00c9da6d0a115018672310850489137b3da046 + languageName: node + linkType: hard + +"optionator@npm:^0.9.3": + version: 0.9.4 + resolution: "optionator@npm:0.9.4" + dependencies: + deep-is: "npm:^0.1.3" + fast-levenshtein: "npm:^2.0.6" + levn: "npm:^0.4.1" + prelude-ls: "npm:^1.2.1" + type-check: "npm:^0.4.0" + word-wrap: "npm:^1.2.5" + checksum: 10c0/4afb687a059ee65b61df74dfe87d8d6815cd6883cb8b3d5883a910df72d0f5d029821f37025e4bccf4048873dbdb09acc6d303d27b8f76b1a80dd5a7d5334675 + languageName: node + linkType: hard + +"p-limit@npm:^3.0.2": + version: 3.1.0 + resolution: "p-limit@npm:3.1.0" + dependencies: + yocto-queue: "npm:^0.1.0" + checksum: 10c0/9db675949dbdc9c3763c89e748d0ef8bdad0afbb24d49ceaf4c46c02c77d30db4e0652ed36d0a0a7a95154335fab810d95c86153105bb73b3a90448e2bb14e1a + languageName: node + linkType: hard + +"p-locate@npm:^5.0.0": + version: 5.0.0 + resolution: "p-locate@npm:5.0.0" + dependencies: + p-limit: "npm:^3.0.2" + checksum: 10c0/2290d627ab7903b8b70d11d384fee714b797f6040d9278932754a6860845c4d3190603a0772a663c8cb5a7b21d1b16acb3a6487ebcafa9773094edc3dfe6009a + languageName: node + linkType: hard + +"p-map@npm:^7.0.2": + version: 7.0.3 + resolution: "p-map@npm:7.0.3" + checksum: 10c0/46091610da2b38ce47bcd1d8b4835a6fa4e832848a6682cf1652bc93915770f4617afc844c10a77d1b3e56d2472bb2d5622353fa3ead01a7f42b04fc8e744a5c + languageName: node + linkType: hard + +"package-json-from-dist@npm:^1.0.0": + version: 1.0.1 + resolution: "package-json-from-dist@npm:1.0.1" + checksum: 10c0/62ba2785eb655fec084a257af34dbe24292ab74516d6aecef97ef72d4897310bc6898f6c85b5cd22770eaa1ce60d55a0230e150fb6a966e3ecd6c511e23d164b + languageName: node + linkType: hard + +"parent-module@npm:^1.0.0": + version: 1.0.1 + resolution: "parent-module@npm:1.0.1" + dependencies: + callsites: "npm:^3.0.0" + checksum: 10c0/c63d6e80000d4babd11978e0d3fee386ca7752a02b035fd2435960ffaa7219dc42146f07069fb65e6e8bf1caef89daf9af7535a39bddf354d78bf50d8294f556 + languageName: node + linkType: hard + +"path-exists@npm:^4.0.0": + version: 4.0.0 + resolution: "path-exists@npm:4.0.0" + checksum: 10c0/8c0bd3f5238188197dc78dced15207a4716c51cc4e3624c44fc97acf69558f5ebb9a2afff486fe1b4ee148e0c133e96c5e11a9aa5c48a3006e3467da070e5e1b + languageName: node + linkType: hard + +"path-key@npm:^3.1.0": + version: 3.1.1 + resolution: "path-key@npm:3.1.1" + checksum: 10c0/748c43efd5a569c039d7a00a03b58eecd1d75f3999f5a28303d75f521288df4823bc057d8784eb72358b2895a05f29a070bc9f1f17d28226cc4e62494cc58c4c + languageName: node + linkType: hard + +"path-scurry@npm:^1.11.1": + version: 1.11.1 + resolution: "path-scurry@npm:1.11.1" + dependencies: + lru-cache: "npm:^10.2.0" + minipass: "npm:^5.0.0 || ^6.0.2 || ^7.0.0" + checksum: 10c0/32a13711a2a505616ae1cc1b5076801e453e7aae6ac40ab55b388bb91b9d0547a52f5aaceff710ea400205f18691120d4431e520afbe4266b836fadede15872d + languageName: node + linkType: hard + +"path-scurry@npm:^2.0.0": + version: 2.0.0 + resolution: "path-scurry@npm:2.0.0" + dependencies: + lru-cache: "npm:^11.0.0" + minipass: "npm:^7.1.2" + checksum: 10c0/3da4adedaa8e7ef8d6dc4f35a0ff8f05a9b4d8365f2b28047752b62d4c1ad73eec21e37b1579ef2d075920157856a3b52ae8309c480a6f1a8bbe06ff8e52b33c + languageName: node + linkType: hard + +"path-type@npm:^4.0.0": + version: 4.0.0 + resolution: "path-type@npm:4.0.0" + checksum: 10c0/666f6973f332f27581371efaf303fd6c272cc43c2057b37aa99e3643158c7e4b2626549555d88626e99ea9e046f82f32e41bbde5f1508547e9a11b149b52387c + languageName: node + linkType: hard + +"pause-stream@npm:0.0.11": + version: 0.0.11 + resolution: "pause-stream@npm:0.0.11" + dependencies: + through: "npm:~2.3" + checksum: 10c0/86f12c64cdaaa8e45ebaca4e39a478e1442db8b4beabc280b545bfaf79c0e2f33c51efb554aace5c069cc441c7b924ba484837b345eaa4ba6fc940d62f826802 + languageName: node + linkType: hard + +"picomatch@npm:^2.0.4, picomatch@npm:^2.2.1, picomatch@npm:^2.3.1": + version: 2.3.1 + resolution: "picomatch@npm:2.3.1" + checksum: 10c0/26c02b8d06f03206fc2ab8d16f19960f2ff9e81a658f831ecb656d8f17d9edc799e8364b1f4a7873e89d9702dff96204be0fa26fe4181f6843f040f819dac4be + languageName: node + linkType: hard + +"plimit-lit@npm:^1.2.6": + version: 1.6.1 + resolution: "plimit-lit@npm:1.6.1" + dependencies: + queue-lit: "npm:^1.5.1" + checksum: 10c0/af5d351bb55afe1eaa84b27c2b329699e150e4cf70464f3d474f5eabe9bdb9f48ed378ada1498d3b893f68ee7da2423ba6d9a4d88b1429d3b0aea22afcf5292b + languageName: node + linkType: hard + +"prelude-ls@npm:^1.2.1": + version: 1.2.1 + resolution: "prelude-ls@npm:1.2.1" + checksum: 10c0/b00d617431e7886c520a6f498a2e14c75ec58f6d93ba48c3b639cf241b54232d90daa05d83a9e9b9fef6baa63cb7e1e4602c2372fea5bc169668401eb127d0cd + languageName: node + linkType: hard + +"prettier-linter-helpers@npm:^1.0.0": + version: 1.0.0 + resolution: "prettier-linter-helpers@npm:1.0.0" + dependencies: + fast-diff: "npm:^1.1.2" + checksum: 10c0/81e0027d731b7b3697ccd2129470ed9913ecb111e4ec175a12f0fcfab0096516373bf0af2fef132af50cafb0a905b74ff57996d615f59512bb9ac7378fcc64ab + languageName: node + linkType: hard + +"prettier@npm:^3.4.2": + version: 3.4.2 + resolution: "prettier@npm:3.4.2" + bin: + prettier: bin/prettier.cjs + checksum: 10c0/99e076a26ed0aba4ebc043880d0f08bbb8c59a4c6641cdee6cdadf2205bdd87aa1d7823f50c3aea41e015e99878d37c58d7b5f0e663bba0ef047f94e36b96446 + languageName: node + linkType: hard + +"proc-log@npm:^5.0.0": + version: 5.0.0 + resolution: "proc-log@npm:5.0.0" + checksum: 10c0/bbe5edb944b0ad63387a1d5b1911ae93e05ce8d0f60de1035b218cdcceedfe39dbd2c697853355b70f1a090f8f58fe90da487c85216bf9671f9499d1a897e9e3 + languageName: node + linkType: hard + +"promise-retry@npm:^2.0.1": + version: 2.0.1 + resolution: "promise-retry@npm:2.0.1" + dependencies: + err-code: "npm:^2.0.2" + retry: "npm:^0.12.0" + checksum: 10c0/9c7045a1a2928094b5b9b15336dcd2a7b1c052f674550df63cc3f36cd44028e5080448175b6f6ca32b642de81150f5e7b1a98b728f15cb069f2dd60ac2616b96 + languageName: node + linkType: hard + +"ps-tree@npm:^1.2.0": + version: 1.2.0 + resolution: "ps-tree@npm:1.2.0" + dependencies: + event-stream: "npm:=3.3.4" + bin: + ps-tree: ./bin/ps-tree.js + checksum: 10c0/9d1c159e0890db5aa05f84d125193c2190a6c4ecd457596fd25e7611f8f747292a846459dcc0244e27d45529d4cea6d1010c3a2a087fad02624d12fdb7d97c22 + languageName: node + linkType: hard + +"punycode@npm:^2.1.0": + version: 2.3.1 + resolution: "punycode@npm:2.3.1" + checksum: 10c0/14f76a8206bc3464f794fb2e3d3cc665ae416c01893ad7a02b23766eb07159144ee612ad67af5e84fa4479ccfe67678c4feb126b0485651b302babf66f04f9e9 + languageName: node + linkType: hard + +"queue-lit@npm:^1.5.1": + version: 1.5.2 + resolution: "queue-lit@npm:1.5.2" + checksum: 10c0/8aa838b2c939aeaa6cd272b5b6b172379a3fa1d9193b2a3e687643c68c0efee3cd3493af4f1f8a11ff79b8207e4d00cc5d0b072f6e4bbeaaa27ee01f567ec4ac + languageName: node + linkType: hard + +"queue-microtask@npm:^1.2.2": + version: 1.2.3 + resolution: "queue-microtask@npm:1.2.3" + checksum: 10c0/900a93d3cdae3acd7d16f642c29a642aea32c2026446151f0778c62ac089d4b8e6c986811076e1ae180a694cedf077d453a11b58ff0a865629a4f82ab558e102 + languageName: node + linkType: hard + +"readdirp@npm:~3.6.0": + version: 3.6.0 + resolution: "readdirp@npm:3.6.0" + dependencies: + picomatch: "npm:^2.2.1" + checksum: 10c0/6fa848cf63d1b82ab4e985f4cf72bd55b7dcfd8e0a376905804e48c3634b7e749170940ba77b32804d5fe93b3cc521aa95a8d7e7d725f830da6d93f3669ce66b + languageName: node + linkType: hard + +"resolve-from@npm:^4.0.0": + version: 4.0.0 + resolution: "resolve-from@npm:4.0.0" + checksum: 10c0/8408eec31a3112ef96e3746c37be7d64020cda07c03a920f5024e77290a218ea758b26ca9529fd7b1ad283947f34b2291c1c0f6aa0ed34acfdda9c6014c8d190 + languageName: node + linkType: hard + +"retry@npm:^0.12.0": + version: 0.12.0 + resolution: "retry@npm:0.12.0" + checksum: 10c0/59933e8501727ba13ad73ef4a04d5280b3717fd650408460c987392efe9d7be2040778ed8ebe933c5cbd63da3dcc37919c141ef8af0a54a6e4fca5a2af177bfe + languageName: node + linkType: hard + +"reusify@npm:^1.0.4": + version: 1.0.4 + resolution: "reusify@npm:1.0.4" + checksum: 10c0/c19ef26e4e188f408922c46f7ff480d38e8dfc55d448310dfb518736b23ed2c4f547fb64a6ed5bdba92cd7e7ddc889d36ff78f794816d5e71498d645ef476107 + languageName: node + linkType: hard + +"rimraf@npm:^5.0.5": + version: 5.0.10 + resolution: "rimraf@npm:5.0.10" + dependencies: + glob: "npm:^10.3.7" + bin: + rimraf: dist/esm/bin.mjs + checksum: 10c0/7da4fd0e15118ee05b918359462cfa1e7fe4b1228c7765195a45b55576e8c15b95db513b8466ec89129666f4af45ad978a3057a02139afba1a63512a2d9644cc + languageName: node + linkType: hard + +"rimraf@npm:^6.0.1": + version: 6.0.1 + resolution: "rimraf@npm:6.0.1" + dependencies: + glob: "npm:^11.0.0" + package-json-from-dist: "npm:^1.0.0" + bin: + rimraf: dist/esm/bin.mjs + checksum: 10c0/b30b6b072771f0d1e73b4ca5f37bb2944ee09375be9db5f558fcd3310000d29dfcfa93cf7734d75295ad5a7486dc8e40f63089ced1722a664539ffc0c3ece8c6 + languageName: node + linkType: hard + +"run-parallel@npm:^1.1.9": + version: 1.2.0 + resolution: "run-parallel@npm:1.2.0" + dependencies: + queue-microtask: "npm:^1.2.2" + checksum: 10c0/200b5ab25b5b8b7113f9901bfe3afc347e19bb7475b267d55ad0eb86a62a46d77510cb0f232507c9e5d497ebda569a08a9867d0d14f57a82ad5564d991588b39 + languageName: node + linkType: hard + +"safer-buffer@npm:>= 2.1.2 < 3.0.0": + version: 2.1.2 + resolution: "safer-buffer@npm:2.1.2" + checksum: 10c0/7e3c8b2e88a1841c9671094bbaeebd94448111dd90a81a1f606f3f67708a6ec57763b3b47f06da09fc6054193e0e6709e77325415dc8422b04497a8070fa02d4 + languageName: node + linkType: hard + +"semver@npm:^7.3.5, semver@npm:^7.6.0": + version: 7.6.3 + resolution: "semver@npm:7.6.3" + bin: + semver: bin/semver.js + checksum: 10c0/88f33e148b210c153873cb08cfe1e281d518aaa9a666d4d148add6560db5cd3c582f3a08ccb91f38d5f379ead256da9931234ed122057f40bb5766e65e58adaf + languageName: node + linkType: hard + +"shebang-command@npm:^2.0.0": + version: 2.0.0 + resolution: "shebang-command@npm:2.0.0" + dependencies: + shebang-regex: "npm:^3.0.0" + checksum: 10c0/a41692e7d89a553ef21d324a5cceb5f686d1f3c040759c50aab69688634688c5c327f26f3ecf7001ebfd78c01f3c7c0a11a7c8bfd0a8bc9f6240d4f40b224e4e + languageName: node + linkType: hard + +"shebang-regex@npm:^3.0.0": + version: 3.0.0 + resolution: "shebang-regex@npm:3.0.0" + checksum: 10c0/1dbed0726dd0e1152a92696c76c7f06084eb32a90f0528d11acd764043aacf76994b2fb30aa1291a21bd019d6699164d048286309a278855ee7bec06cf6fb690 + languageName: node + linkType: hard + +"signal-exit@npm:^4.0.1": + version: 4.1.0 + resolution: "signal-exit@npm:4.1.0" + checksum: 10c0/41602dce540e46d599edba9d9860193398d135f7ff72cab629db5171516cfae628d21e7bfccde1bbfdf11c48726bc2a6d1a8fb8701125852fbfda7cf19c6aa83 + languageName: node + linkType: hard + +"slash@npm:^3.0.0": + version: 3.0.0 + resolution: "slash@npm:3.0.0" + checksum: 10c0/e18488c6a42bdfd4ac5be85b2ced3ccd0224773baae6ad42cfbb9ec74fc07f9fa8396bd35ee638084ead7a2a0818eb5e7151111544d4731ce843019dab4be47b + languageName: node + linkType: hard + +"smart-buffer@npm:^4.2.0": + version: 4.2.0 + resolution: "smart-buffer@npm:4.2.0" + checksum: 10c0/a16775323e1404dd43fabafe7460be13a471e021637bc7889468eb45ce6a6b207261f454e4e530a19500cc962c4cc5348583520843b363f4193cee5c00e1e539 + languageName: node + linkType: hard + +"socks-proxy-agent@npm:^8.0.3": + version: 8.0.5 + resolution: "socks-proxy-agent@npm:8.0.5" + dependencies: + agent-base: "npm:^7.1.2" + debug: "npm:^4.3.4" + socks: "npm:^2.8.3" + checksum: 10c0/5d2c6cecba6821389aabf18728325730504bf9bb1d9e342e7987a5d13badd7a98838cc9a55b8ed3cb866ad37cc23e1086f09c4d72d93105ce9dfe76330e9d2a6 + languageName: node + linkType: hard + +"socks@npm:^2.8.3": + version: 2.8.3 + resolution: "socks@npm:2.8.3" + dependencies: + ip-address: "npm:^9.0.5" + smart-buffer: "npm:^4.2.0" + checksum: 10c0/d54a52bf9325165770b674a67241143a3d8b4e4c8884560c4e0e078aace2a728dffc7f70150660f51b85797c4e1a3b82f9b7aa25e0a0ceae1a243365da5c51a7 + languageName: node + linkType: hard + +"split@npm:0.3": + version: 0.3.3 + resolution: "split@npm:0.3.3" + dependencies: + through: "npm:2" + checksum: 10c0/88c09b1b4de84953bf5d6c153123a1fbb20addfea9381f70d27b4eb6b2bfbadf25d313f8f5d3fd727d5679b97bfe54da04766b91010f131635bf49e51d5db3fc + languageName: node + linkType: hard + +"sprintf-js@npm:^1.1.3": + version: 1.1.3 + resolution: "sprintf-js@npm:1.1.3" + checksum: 10c0/09270dc4f30d479e666aee820eacd9e464215cdff53848b443964202bf4051490538e5dd1b42e1a65cf7296916ca17640aebf63dae9812749c7542ee5f288dec + languageName: node + linkType: hard + +"ssri@npm:^12.0.0": + version: 12.0.0 + resolution: "ssri@npm:12.0.0" + dependencies: + minipass: "npm:^7.0.3" + checksum: 10c0/caddd5f544b2006e88fa6b0124d8d7b28208b83c72d7672d5ade44d794525d23b540f3396108c4eb9280dcb7c01f0bef50682f5b4b2c34291f7c5e211fd1417d + languageName: node + linkType: hard + +"stream-combiner@npm:~0.0.4": + version: 0.0.4 + resolution: "stream-combiner@npm:0.0.4" + dependencies: + duplexer: "npm:~0.1.1" + checksum: 10c0/8075a94c0eb0f20450a8236cb99d4ce3ea6e6a4b36d8baa7440b1a08cde6ffd227debadffaecd80993bd334282875d0e927ab5b88484625e01970dd251004ff5 + languageName: node + linkType: hard + +"string-argv@npm:^0.3.1": + version: 0.3.2 + resolution: "string-argv@npm:0.3.2" + checksum: 10c0/75c02a83759ad1722e040b86823909d9a2fc75d15dd71ec4b537c3560746e33b5f5a07f7332d1e3f88319909f82190843aa2f0a0d8c8d591ec08e93d5b8dec82 + languageName: node + linkType: hard + +"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.1.0": + version: 4.2.3 + resolution: "string-width@npm:4.2.3" + dependencies: + emoji-regex: "npm:^8.0.0" + is-fullwidth-code-point: "npm:^3.0.0" + strip-ansi: "npm:^6.0.1" + checksum: 10c0/1e525e92e5eae0afd7454086eed9c818ee84374bb80328fc41217ae72ff5f065ef1c9d7f72da41de40c75fa8bb3dee63d92373fd492c84260a552c636392a47b + languageName: node + linkType: hard + +"string-width@npm:^5.0.1, string-width@npm:^5.1.2": + version: 5.1.2 + resolution: "string-width@npm:5.1.2" + dependencies: + eastasianwidth: "npm:^0.2.0" + emoji-regex: "npm:^9.2.2" + strip-ansi: "npm:^7.0.1" + checksum: 10c0/ab9c4264443d35b8b923cbdd513a089a60de339216d3b0ed3be3ba57d6880e1a192b70ae17225f764d7adbf5994e9bb8df253a944736c15a0240eff553c678ca + languageName: node + linkType: hard + +"strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1": + version: 6.0.1 + resolution: "strip-ansi@npm:6.0.1" + dependencies: + ansi-regex: "npm:^5.0.1" + checksum: 10c0/1ae5f212a126fe5b167707f716942490e3933085a5ff6c008ab97ab2f272c8025d3aa218b7bd6ab25729ca20cc81cddb252102f8751e13482a5199e873680952 + languageName: node + linkType: hard + +"strip-ansi@npm:^7.0.1": + version: 7.1.0 + resolution: "strip-ansi@npm:7.1.0" + dependencies: + ansi-regex: "npm:^6.0.1" + checksum: 10c0/a198c3762e8832505328cbf9e8c8381de14a4fa50a4f9b2160138158ea88c0f5549fb50cb13c651c3088f47e63a108b34622ec18c0499b6c8c3a5ddf6b305ac4 + languageName: node + linkType: hard + +"strip-json-comments@npm:^3.1.1": + version: 3.1.1 + resolution: "strip-json-comments@npm:3.1.1" + checksum: 10c0/9681a6257b925a7fa0f285851c0e613cc934a50661fa7bb41ca9cbbff89686bb4a0ee366e6ecedc4daafd01e83eee0720111ab294366fe7c185e935475ebcecd + languageName: node + linkType: hard + +"supports-color@npm:^7.1.0": + version: 7.2.0 + resolution: "supports-color@npm:7.2.0" + dependencies: + has-flag: "npm:^4.0.0" + checksum: 10c0/afb4c88521b8b136b5f5f95160c98dee7243dc79d5432db7efc27efb219385bbc7d9427398e43dd6cc730a0f87d5085ce1652af7efbe391327bc0a7d0f7fc124 + languageName: node + linkType: hard + +"synckit@npm:^0.9.1": + version: 0.9.2 + resolution: "synckit@npm:0.9.2" + dependencies: + "@pkgr/core": "npm:^0.1.0" + tslib: "npm:^2.6.2" + checksum: 10c0/e0c262817444e5b872708adb6f5ad37951ba33f6b2d1d4477d45db1f57573a784618ceed5e6614e0225db330632b1f6b95bb74d21e4d013e45ad4bde03d0cb59 + languageName: node + linkType: hard + +"tar@npm:^7.4.3": + version: 7.4.3 + resolution: "tar@npm:7.4.3" + dependencies: + "@isaacs/fs-minipass": "npm:^4.0.0" + chownr: "npm:^3.0.0" + minipass: "npm:^7.1.2" + minizlib: "npm:^3.0.1" + mkdirp: "npm:^3.0.1" + yallist: "npm:^5.0.0" + checksum: 10c0/d4679609bb2a9b48eeaf84632b6d844128d2412b95b6de07d53d8ee8baf4ca0857c9331dfa510390a0727b550fd543d4d1a10995ad86cdf078423fbb8d99831d + languageName: node + linkType: hard + +"through@npm:2, through@npm:~2.3, through@npm:~2.3.1": + version: 2.3.8 + resolution: "through@npm:2.3.8" + checksum: 10c0/4b09f3774099de0d4df26d95c5821a62faee32c7e96fb1f4ebd54a2d7c11c57fe88b0a0d49cf375de5fee5ae6bf4eb56dbbf29d07366864e2ee805349970d3cc + languageName: node + linkType: hard + +"to-regex-range@npm:^5.0.1": + version: 5.0.1 + resolution: "to-regex-range@npm:5.0.1" + dependencies: + is-number: "npm:^7.0.0" + checksum: 10c0/487988b0a19c654ff3e1961b87f471702e708fa8a8dd02a298ef16da7206692e8552a0250e8b3e8759270f62e9d8314616f6da274734d3b558b1fc7b7724e892 + languageName: node + linkType: hard + +"ts-api-utils@npm:^2.0.0": + version: 2.0.0 + resolution: "ts-api-utils@npm:2.0.0" + peerDependencies: + typescript: ">=4.8.4" + checksum: 10c0/6165e29a5b75bd0218e3cb0f9ee31aa893dbd819c2e46dbb086c841121eb0436ed47c2c18a20cb3463d74fd1fb5af62e2604ba5971cc48e5b38ebbdc56746dfc + languageName: node + linkType: hard + +"tsc-alias@npm:^1.8.10": + version: 1.8.10 + resolution: "tsc-alias@npm:1.8.10" + dependencies: + chokidar: "npm:^3.5.3" + commander: "npm:^9.0.0" + globby: "npm:^11.0.4" + mylas: "npm:^2.1.9" + normalize-path: "npm:^3.0.0" + plimit-lit: "npm:^1.2.6" + bin: + tsc-alias: dist/bin/index.js + checksum: 10c0/6f319d37b35d2f660c09c4a5413305c78943dd09bdaf395f4c1da69e19ad15b4d149db28d9251acd8bb52e755af55895018b2fe55f1511774da2e9e30a5c826a + languageName: node + linkType: hard + +"tsc-watch@npm:6.2.1": + version: 6.2.1 + resolution: "tsc-watch@npm:6.2.1" + dependencies: + cross-spawn: "npm:^7.0.3" + node-cleanup: "npm:^2.1.2" + ps-tree: "npm:^1.2.0" + string-argv: "npm:^0.3.1" + peerDependencies: + typescript: "*" + bin: + tsc-watch: dist/lib/tsc-watch.js + checksum: 10c0/f5fe19e5ac9f4c42a5600c20aee9ff49e282f11813aead65ed58fa11d98a20f5a82bf4f931897270f49f6475dd54e9aab9c46a07c3801b8d237dfbe77bcf1bfc + languageName: node + linkType: hard + +"tslib@npm:^2.6.2": + version: 2.8.1 + resolution: "tslib@npm:2.8.1" + checksum: 10c0/9c4759110a19c53f992d9aae23aac5ced636e99887b51b9e61def52611732872ff7668757d4e4c61f19691e36f4da981cd9485e869b4a7408d689f6bf1f14e62 + languageName: node + linkType: hard + +"type-check@npm:^0.4.0, type-check@npm:~0.4.0": + version: 0.4.0 + resolution: "type-check@npm:0.4.0" + dependencies: + prelude-ls: "npm:^1.2.1" + checksum: 10c0/7b3fd0ed43891e2080bf0c5c504b418fbb3e5c7b9708d3d015037ba2e6323a28152ec163bcb65212741fa5d2022e3075ac3c76440dbd344c9035f818e8ecee58 + languageName: node + linkType: hard + +"typescript-eslint@npm:^8.18.2": + version: 8.20.0 + resolution: "typescript-eslint@npm:8.20.0" + dependencies: + "@typescript-eslint/eslint-plugin": "npm:8.20.0" + "@typescript-eslint/parser": "npm:8.20.0" + "@typescript-eslint/utils": "npm:8.20.0" + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: ">=4.8.4 <5.8.0" + checksum: 10c0/049e0fa000657232c0fe26a062ef6a9cd16c5a58c814a74ac45971554c8b6bc67355821a66229f9537e819939a2ab065e7fcba9a70cd95c8283630dc58ac0144 + languageName: node + linkType: hard + +"typescript@npm:^5.7.2": + version: 5.7.3 + resolution: "typescript@npm:5.7.3" + bin: + tsc: bin/tsc + tsserver: bin/tsserver + checksum: 10c0/b7580d716cf1824736cc6e628ab4cd8b51877408ba2be0869d2866da35ef8366dd6ae9eb9d0851470a39be17cbd61df1126f9e211d8799d764ea7431d5435afa + languageName: node + linkType: hard + +"typescript@patch:typescript@npm%3A^5.7.2#optional!builtin": + version: 5.7.3 + resolution: "typescript@patch:typescript@npm%3A5.7.3#optional!builtin::version=5.7.3&hash=5786d5" + bin: + tsc: bin/tsc + tsserver: bin/tsserver + checksum: 10c0/6fd7e0ed3bf23a81246878c613423730c40e8bdbfec4c6e4d7bf1b847cbb39076e56ad5f50aa9d7ebd89877999abaee216002d3f2818885e41c907caaa192cc4 + languageName: node + linkType: hard + +"unique-filename@npm:^4.0.0": + version: 4.0.0 + resolution: "unique-filename@npm:4.0.0" + dependencies: + unique-slug: "npm:^5.0.0" + checksum: 10c0/38ae681cceb1408ea0587b6b01e29b00eee3c84baee1e41fd5c16b9ed443b80fba90c40e0ba69627e30855570a34ba8b06702d4a35035d4b5e198bf5a64c9ddc + languageName: node + linkType: hard + +"unique-slug@npm:^5.0.0": + version: 5.0.0 + resolution: "unique-slug@npm:5.0.0" + dependencies: + imurmurhash: "npm:^0.1.4" + checksum: 10c0/d324c5a44887bd7e105ce800fcf7533d43f29c48757ac410afd42975de82cc38ea2035c0483f4de82d186691bf3208ef35c644f73aa2b1b20b8e651be5afd293 + languageName: node + linkType: hard + +"uri-js@npm:^4.2.2": + version: 4.4.1 + resolution: "uri-js@npm:4.4.1" + dependencies: + punycode: "npm:^2.1.0" + checksum: 10c0/4ef57b45aa820d7ac6496e9208559986c665e49447cb072744c13b66925a362d96dd5a46c4530a6b8e203e5db5fe849369444440cb22ecfc26c679359e5dfa3c + languageName: node + linkType: hard + +"which@npm:^2.0.1": + version: 2.0.2 + resolution: "which@npm:2.0.2" + dependencies: + isexe: "npm:^2.0.0" + bin: + node-which: ./bin/node-which + checksum: 10c0/66522872a768b60c2a65a57e8ad184e5372f5b6a9ca6d5f033d4b0dc98aff63995655a7503b9c0a2598936f532120e81dd8cc155e2e92ed662a2b9377cc4374f + languageName: node + linkType: hard + +"which@npm:^5.0.0": + version: 5.0.0 + resolution: "which@npm:5.0.0" + dependencies: + isexe: "npm:^3.1.1" + bin: + node-which: bin/which.js + checksum: 10c0/e556e4cd8b7dbf5df52408c9a9dd5ac6518c8c5267c8953f5b0564073c66ed5bf9503b14d876d0e9c7844d4db9725fb0dcf45d6e911e17e26ab363dc3965ae7b + languageName: node + linkType: hard + +"word-wrap@npm:^1.2.5": + version: 1.2.5 + resolution: "word-wrap@npm:1.2.5" + checksum: 10c0/e0e4a1ca27599c92a6ca4c32260e8a92e8a44f4ef6ef93f803f8ed823f486e0889fc0b93be4db59c8d51b3064951d25e43d434e95dc8c960cc3a63d65d00ba20 + languageName: node + linkType: hard + +"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0": + version: 7.0.0 + resolution: "wrap-ansi@npm:7.0.0" + dependencies: + ansi-styles: "npm:^4.0.0" + string-width: "npm:^4.1.0" + strip-ansi: "npm:^6.0.0" + checksum: 10c0/d15fc12c11e4cbc4044a552129ebc75ee3f57aa9c1958373a4db0292d72282f54373b536103987a4a7594db1ef6a4f10acf92978f79b98c49306a4b58c77d4da + languageName: node + linkType: hard + +"wrap-ansi@npm:^8.1.0": + version: 8.1.0 + resolution: "wrap-ansi@npm:8.1.0" + dependencies: + ansi-styles: "npm:^6.1.0" + string-width: "npm:^5.0.1" + strip-ansi: "npm:^7.0.1" + checksum: 10c0/138ff58a41d2f877eae87e3282c0630fc2789012fc1af4d6bd626eeb9a2f9a65ca92005e6e69a75c7b85a68479fe7443c7dbe1eb8fbaa681a4491364b7c55c60 + languageName: node + linkType: hard + +"yallist@npm:^4.0.0": + version: 4.0.0 + resolution: "yallist@npm:4.0.0" + checksum: 10c0/2286b5e8dbfe22204ab66e2ef5cc9bbb1e55dfc873bbe0d568aa943eb255d131890dfd5bf243637273d31119b870f49c18fcde2c6ffbb7a7a092b870dc90625a + languageName: node + linkType: hard + +"yallist@npm:^5.0.0": + version: 5.0.0 + resolution: "yallist@npm:5.0.0" + checksum: 10c0/a499c81ce6d4a1d260d4ea0f6d49ab4da09681e32c3f0472dee16667ed69d01dae63a3b81745a24bd78476ec4fcf856114cb4896ace738e01da34b2c42235416 + languageName: node + linkType: hard + +"yocto-queue@npm:^0.1.0": + version: 0.1.0 + resolution: "yocto-queue@npm:0.1.0" + checksum: 10c0/dceb44c28578b31641e13695d200d34ec4ab3966a5729814d5445b194933c096b7ced71494ce53a0e8820685d1d010df8b2422e5bf2cdea7e469d97ffbea306f + languageName: node + linkType: hard