From 17380c173f2653e8b1e9c635275c2c2e7bae7108 Mon Sep 17 00:00:00 2001 From: "Bug, Ltd." <194549623+bugltd@users.noreply.github.com> Date: Tue, 14 Jan 2025 16:15:47 +0100 Subject: [PATCH] Bootstrap (#1) bootstrap repo with files from local --- .gitignore | 203 + .prettierignore | 9 + .prettierrc.json | 22 + .vscode/settings.json | 5 + .vscode/tasks.json | 27 + .yarnrc.yml | 1 + ComfyLab-Pack.code-workspace | 7 + __init__.py | 28 + build/replacers.js/mock.js | 20 + build/replacers.js/mock.ts | 23 + build/replacers.js/tsconfig.replacers.json | 23 + dist/js/.mock/scripts/api.js | 1 + dist/js/.mock/scripts/app.js | 1 + dist/js/.mock/scripts/ui.js | 1 + .../scripts/ui/components/asyncDialog.js | 1 + dist/js/.mock/scripts/widgets.js | 1 + dist/js/custom.js | 287 + dist/js/nodes/config.js | 212 + dist/js/nodes/debug.js | 86 + dist/js/nodes/input.js | 15 + dist/js/nodes/list.js | 15 + dist/js/register.js | 68 + dist/js/shared/common.js | 55 + dist/js/shared/config.common.js | 4 + dist/js/shared/config.output.js | 144 + dist/js/shared/dynamic_connections.js | 153 + dist/js/shared/error.js | 77 + dist/js/shared/types.js | 28 + dist/js/shared/utils.js | 240 + dist/js/widgets/factories.js | 205 + dist/js/widgets/misc.js | 71 + dist/js/widgets/queue.js | 64 + eslint.config.js | 24 + node_list.json | 29 + package.json | 29 + requirements.txt | 5 + src/python/__init__.py | 0 src/python/collection/__init__.py | 0 src/python/collection/collect_nodes.py | 50 + src/python/collection/register_nodes.py | 12 + src/python/nodes/__init__.py | 0 src/python/nodes/config.py | 50 + src/python/nodes/debug.py | 82 + src/python/nodes/input.py | 170 + src/python/nodes/list.py | 385 + src/python/nodes/plot.py | 506 + src/python/nodes/queue.py | 211 + src/python/nodes/utils.py | 267 + src/python/shared/__init__.py | 0 src/python/shared/api.py | 158 + src/python/shared/grid.py | 295 + src/python/shared/json_validation.py | 77 + src/python/shared/pager.py | 90 + src/python/shared/plot_data.py | 52 + src/python/shared/utils.py | 46 + src/schema/config.multi.schema.json | 10 + src/schema/config.node.schema.json | 7 + src/schema/config.output.auto.schema.json | 27 + src/schema/config.output.schema.json | 26 + src/ts/.d.ts/comfyui-frontend-types_alt.d.ts | 97734 ++++++++++++++++ src/ts/.mock/scripts/api.ts | 3 + src/ts/.mock/scripts/app.ts | 3 + src/ts/.mock/scripts/ui.ts | 3 + .../scripts/ui/components/asyncDialog.ts | 3 + src/ts/.mock/scripts/widgets.ts | 3 + src/ts/custom.ts | 332 + src/ts/nodes/config.ts | 307 + src/ts/nodes/debug.ts | 114 + src/ts/nodes/input.ts | 25 + src/ts/nodes/list.ts | 25 + src/ts/register.ts | 89 + src/ts/shared/common.ts | 75 + src/ts/shared/config.common.ts | 31 + src/ts/shared/config.output.ts | 190 + src/ts/shared/dynamic_connections.ts | 320 + src/ts/shared/error.ts | 108 + src/ts/shared/types.ts | 27 + src/ts/shared/utils.ts | 338 + src/ts/widgets/factories.ts | 367 + src/ts/widgets/misc.ts | 134 + src/ts/widgets/queue.ts | 96 + static/Roboto-Bold.ttf | Bin 0 -> 288872 bytes static/Roboto-BoldItalic.ttf | Bin 0 -> 312608 bytes static/Roboto-Italic.ttf | Bin 0 -> 311960 bytes static/Roboto-Regular.ttf | Bin 0 -> 292752 bytes tsconfig.json | 29 + tsconfig.prod.json | 4 + yarn.lock | 2232 + 88 files changed, 107297 insertions(+) create mode 100644 .gitignore create mode 100644 .prettierignore create mode 100644 .prettierrc.json create mode 100644 .vscode/settings.json create mode 100644 .vscode/tasks.json create mode 100644 .yarnrc.yml create mode 100644 ComfyLab-Pack.code-workspace create mode 100644 __init__.py create mode 100644 build/replacers.js/mock.js create mode 100644 build/replacers.js/mock.ts create mode 100644 build/replacers.js/tsconfig.replacers.json create mode 100644 dist/js/.mock/scripts/api.js create mode 100644 dist/js/.mock/scripts/app.js create mode 100644 dist/js/.mock/scripts/ui.js create mode 100644 dist/js/.mock/scripts/ui/components/asyncDialog.js create mode 100644 dist/js/.mock/scripts/widgets.js create mode 100644 dist/js/custom.js create mode 100644 dist/js/nodes/config.js create mode 100644 dist/js/nodes/debug.js create mode 100644 dist/js/nodes/input.js create mode 100644 dist/js/nodes/list.js create mode 100644 dist/js/register.js create mode 100644 dist/js/shared/common.js create mode 100644 dist/js/shared/config.common.js create mode 100644 dist/js/shared/config.output.js create mode 100644 dist/js/shared/dynamic_connections.js create mode 100644 dist/js/shared/error.js create mode 100644 dist/js/shared/types.js create mode 100644 dist/js/shared/utils.js create mode 100644 dist/js/widgets/factories.js create mode 100644 dist/js/widgets/misc.js create mode 100644 dist/js/widgets/queue.js create mode 100644 eslint.config.js create mode 100644 node_list.json create mode 100644 package.json create mode 100644 requirements.txt create mode 100644 src/python/__init__.py create mode 100644 src/python/collection/__init__.py create mode 100644 src/python/collection/collect_nodes.py create mode 100644 src/python/collection/register_nodes.py create mode 100644 src/python/nodes/__init__.py create mode 100644 src/python/nodes/config.py create mode 100644 src/python/nodes/debug.py create mode 100644 src/python/nodes/input.py create mode 100644 src/python/nodes/list.py create mode 100644 src/python/nodes/plot.py create mode 100644 src/python/nodes/queue.py create mode 100644 src/python/nodes/utils.py create mode 100644 src/python/shared/__init__.py create mode 100644 src/python/shared/api.py create mode 100644 src/python/shared/grid.py create mode 100644 src/python/shared/json_validation.py create mode 100644 src/python/shared/pager.py create mode 100644 src/python/shared/plot_data.py create mode 100644 src/python/shared/utils.py create mode 100644 src/schema/config.multi.schema.json create mode 100644 src/schema/config.node.schema.json create mode 100644 src/schema/config.output.auto.schema.json create mode 100644 src/schema/config.output.schema.json create mode 100644 src/ts/.d.ts/comfyui-frontend-types_alt.d.ts create mode 100644 src/ts/.mock/scripts/api.ts create mode 100644 src/ts/.mock/scripts/app.ts create mode 100644 src/ts/.mock/scripts/ui.ts create mode 100644 src/ts/.mock/scripts/ui/components/asyncDialog.ts create mode 100644 src/ts/.mock/scripts/widgets.ts create mode 100644 src/ts/custom.ts create mode 100644 src/ts/nodes/config.ts create mode 100644 src/ts/nodes/debug.ts create mode 100644 src/ts/nodes/input.ts create mode 100644 src/ts/nodes/list.ts create mode 100644 src/ts/register.ts create mode 100644 src/ts/shared/common.ts create mode 100644 src/ts/shared/config.common.ts create mode 100644 src/ts/shared/config.output.ts create mode 100644 src/ts/shared/dynamic_connections.ts create mode 100644 src/ts/shared/error.ts create mode 100644 src/ts/shared/types.ts create mode 100644 src/ts/shared/utils.ts create mode 100644 src/ts/widgets/factories.ts create mode 100644 src/ts/widgets/misc.ts create mode 100644 src/ts/widgets/queue.ts create mode 100644 static/Roboto-Bold.ttf create mode 100644 static/Roboto-BoldItalic.ttf create mode 100644 static/Roboto-Italic.ttf create mode 100644 static/Roboto-Regular.ttf create mode 100644 tsconfig.json create mode 100644 tsconfig.prod.json create mode 100644 yarn.lock 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 0000000000000000000000000000000000000000..04582297bf4bc373cfcc02bbae939c3d4208f705 GIT binary patch literal 288872 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

>rpZS^frPeN68Rv1)jQws=3I> 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%0DYQ9^8NDxu|4e*${I6b8 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

    RI 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 literal 0 HcmV?d00001 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

    `fGi{M3+rvY>?M#G@x0M5-%i;mjID{kCWxr@=VPIKfgK^dnRdW zZ%RD~1n!Q=JT9>7m(Mp!7wbEH_cgLA6 zrK8nNY8d0)aVoc@Q6ES_v!pwY`0d~|q=EuqLl5W%GodU@GVV(bW0gC@jN!fp&r(Y< zbAv1lQc}TA>#nx0N^v`t^s>XHxYZLHa9>~g*%PF=$}Cl_dg54j2rn$fJ-_mdaJ#wm zu^#zlS9C9CEtD+Qa#><0m$ud$S>TD1z1AJ~w6$KASgYOpDvj%!MP(w`Qcf&)noLL_Q!+5#ynRt7YzJyRNi19=cDg zD%gCq`;77=x6(^_@`z6n zSIKDgbZ-$}*IG^8jdLriRc=*#g!HrS%1X}&302c2y{>m{d#=yQq}2H{uV}huy^Q3nA1;cB`Lz!CWlg`0M4C^i#8>j^9VR^6pt_Z0D06 zb~O-68fk=}lc%wG&CWsU(qINxE33`#Zkh+?qlA znjwuTpKb#wtdHC+)@-TlC$l86!ljhm1s^De{fkO2dn~??QfjI3?qq8|y;d9A$$F`2 zRUnU-@(FFGk#08{?Cq#h*l2~3Wuky5&U;Nzh%d@nhAeEnV^HUF1>1#BOd(kZFb~B4XQE6>Xb|+Ea@2MHI#iydI z{lv{nTRQG;v@f_jXah^pzpYgn+pU5Q?oF$f`0j)j>M^htwshllWIW)q`EgdZKXf?<&^Rse8KY-eOV@nu+B?_IYM%p8{I$g zqsG|hzMwsIg#4|c9Aydq?Mk@0wBa6Jo7pBoi6p}?MLQctRx3`(eou?w)?W&MF!C2!y zFxJR2Bh0;Ggu1aRub7Y%QmTw@jM>--GNO$4)I7uBezmz?E~`hf$5`g(R|Duzs>oiW zH#)~kXETjtGmFS{wLr4|529t9+7EH=Q8S6mQ;{-9wRE>aJJpOaq?y}A)pP$u#|-9J znC!kZ%ej+{_7b78$O<^GvQUp%+=*s>cZ!)6Il$c^659dp1LJ>eut*GJeat4VOTkU9 zcOhTEAg<>j%RwY`;r=4BBqV{gB5^H|2N@EZ^Q<$FM$8w`i10%^zl!8>40D&5-p~SS z5|)N%t-0PR61@be-=7An;B(;J=)*vMG0bhE|3c;j(uzjcX!4Bi20Gm;@D-8KKxrsLoRNg>H^#~??wJckALD){*V+cm*WyYbb8$~zu{sVq#`c0CJWGu13!~v1 z=n2|ZyOBrX0&IldR!jQwebR#dtF<`~|K2C-Xa_&qdfZ$rdHnrPTCUSdaw8gl2{OXX zm-0*{lZA{y+zTQUeF>fdOkjAosc|kerp%k#Mxub$U za91$L`G~Oc_V?})>z+*X1W6Nn6S_8*6G5LyxuCI(gAZhcXBTsmyHbesdU@W^Uq!oj z(XA5WWgfFS{r6^fj2+FqBwE6)q4ZP5VVHZ!K1v-7;hHe&skyyOYS70=Smk7Zrw((U z-q`S>H1s4TURfw41w74=HQb&4J|8=JX1jYmn|Y@jeI@C5E=gC9M`~N8CATMzG3d19 zw0>rciE!t6t}+JS;hn{j+1?@9yoaSq&}_z<#O?|6pnF8uwbcU~Jdl;4q7XEMw-O$B~W1i5BdZ^A^ zb|B^2CFRY>%xk*4D?G*Ah17oqYZh^%q!4wN%hO7>+Fy|GMe2BmL0k1H$elJbc?T~1hE%K*E!>|@?I75SmZVVs#SL8M)fF*q0F z(h=)->^~m;@Kfrrxb-V}Fdz1$X5OUdNMjktm`hkQ-B;!`_fI=1`DCLVT#&q;j*<_X z*YHHhN;@%g@_e$|d@6H-#<^ELHQftAhe)R{^Q{ZmFGy+ZyND`@}lE^&`|qTPeu-T3A!iLieod?#|ce2ASw z?W^v`)@8T8Q`;To9qRY5CDwNL2m27|?{euAW9UO-=r3ZvrhbYduTv+Q%Ush(MC(2b z8FLPXa?d-_)LZn2R(0zQI@VW8*&arvr@V`ItYA zl+@IR-;eRZQvQA=4*v(cqf`$1P_me7Xa@ta>p*N>h`9CK1JqAZ?f2F-#_Ef1tS1B? zzTh4-k4ty^nhZ8?(y#nMn{gxqK77Wk#e3-HZ$pK-zRCQDc4Wp%8hZ|7^Lobg4$|E` z$(Y~JPi6ClOk|DG(O4`)%tF%2+)sE4>1d}VZcaa)%zHA)tjF_3Jlg?Z$*<;bve0fX zab^wa0PD>eGRRIZgP2owgyD?EgJF<*C7qzX*_^rgI{CyTP1`1po_92qA!@mlGIK~D z=)!xsRhZ1>*(`H1eqqZ@#_Ju-Au5g1hOSOeLWrK%)rRcp$LO|`95W9ei(lZnWxe#W`4 z7|U83SEZ)f6tFk8oW-2QHAiFj-2vNMWw8HiDWpu-#qP7snbhSR=}(@s&5vasw$Gtx zQ)Xru28ARC>vrZ0F^r!vD_}Nlr#tij#`M_cpyx9_NXhf*kdrpUn62;Qe&D_;RN_7h zFlNX62|7*9X2SHC-7KEU$VSir^gQbOKz!Yo`sZAF{&WVIC&fO5&p^MU=LhU&_{aWB z$aTCIiM#^5nnwngdDymVq&$g1v;f#4`M>i?p^1)2=fz#x-}R8&8;{uE!sOSUYE+4!X-dGg$Vj zhw$7mSsOn!lgm?m&9nO&*5%J&3-4YxU6G*Y>}JJF#jH+Q?3XlUH>C~NSY7X}7)sa> z0{_2Q4`nbZkG5lKm5V(Ru=>k#JA*9tq@f(K5@JqtKR2exDi~o*cBdjwQ^rl|q)b+u znD0K4lk6Y#vA(1YES5P|L8)WBVQsKhirU4csPVPb3+g9RywNfRmDU?a<)ymI{)@em`dpfUqF?-&_B-BOC|j624EOh4jhQ_X}%)j5a5*caTcfF&D{d)pTzd{oNa^hpJiK z1K0W<8;@t*G7$L%jDR0t9()5!&8+ghx<~ju>B-*EI4EV-(a+o~JkNz(4%=ZJoP%rd z1dhWi+W2L4pSbtkL-hN1VWwHbUC%o3sQHO|%uM5UXDv9vEa7f2bGjRhsqTK;=DLKt zj=pLZ>ynKsoG~=9Ork8|&`a;b=)E0JZgD*Aq^P$v;{Oj%|P7pqN z#9e3q%si~Vd})_(kJ0~YoAfq+myfLj?k?uH{j5aHyPA?#7WON$(QoBpucNu>HA`W9 zp80Y#o)eqO-Yd&UYq{qJ@p?4|ro;(a%B!fMh zkYCB*pi=T<&`#;^S;Kv>4D%SW(X&D(coxbyPkGtFJnx~(N*O|=swah14btU_l?BKJ zK0_8be{pRRcHcc6l*m2pGnkK5V1Ac|IZ`&>xi3{|PZ8#6<_JH-O0M-dx=FeRO_T1v zued%)*j?s5Cz*e&r7lk~wq|9VZpHiOCCqb8deVMM2i29{?9r6g<2bSx^-@WPdqsLP z-i))pWFMt7bGXUOk^8ZZUnXU-T}|b2(^~B%uikSsW6&=R<1+h=<})d4t`MKO(w(ag zvnO%by}%r&f>n(DqSlhvZ0(*<{Ux93&)8rxj+@L+^Wf)qWTQ2n`TcmgWKD2i_!%ad z)Nb-#&E8lB=6|OcU&=E+&33!{=ZdqL8|7q<@d@J;`%9MPKCpjhUat2sKa}-c&!#`? z!yN6DXB2ye$Jis)>!fD9*9RX=ihd`V=k;M8Y`ZUw6K*H7q8y|BWg$K0OtI~u35>?K zUcnNsdqWGz%su^mYz5GLwwAX+j~|Q`{(iqK@+;!$dDjW9dC$MT{G4k&)}#j3tNt|g zS}!>yB@Sau%w#j8G}Nf}eooP^G*k~{0&}f{ep)a$Zv-vmlsSdCC**hLLxtIw{M4T9 zu8C)@vDw|oT->xjpgn#d8`K{5j3!D6`o6SQ40~N=WPw>uN}9z;qZs>}<=De5C(TXf zo{Xat-DvHbJtsX?KFY8M>grqJo!hfCVO5r-ALVM;SX8O4fMgw+2hVG zEsP;Dz}P55k+qPi{C#eI=2nIAxz8AHev#_I!)062DYA{dl&kb{vyBPvZv3&i8YsDp z4ealpWGQ6sH9}^%wk=WMM~J!IOs?veLXu_UmW26DE^@L%E!9D_}5G9U-`pd5?;(@jlp{9 zXLluQ-{nCW-BI=)cT7-H!nV4Hye*jj$FYuR!PtTy(GT^tu1Q&6O8jo1l=Cf@D)dLE z7)BN_4nIaVH5Z7U2eg9H5Cfb_#4-=idkESu{9}49wV`(7npO z+znp_)<+X0#6HY8^no<-EJUvXtPRe~Qo9B=V87lxE1m5(*!dZ@TFze9KHB{R8EWU1 zlC1aAVXI6*Td~2UX_=Ts-g^4HJH0q zbZ4p>?of4xz5g@v6%j18^zWE`Bd6|hxGn>0<|X!E=AYTYKAxO3vD|n{|}_cob(EJ*Ao%C&SEa?3dhhxB7V_1I=UZYtCDK z^9=Xr8DaHjjC>&jd9Rf90-rqQe#@NunK{xuYd&NAUVtALb04zTyvUl$S-}`7%|762 z&I+oTw)-gPH9o^$tI3|UT|m;Cov~YG#@sLDOUByb^ud2Ij-Ry-u|IK$b>9=xDP;69 zPP=F9mh7|FBcF!uGu8xW?V_x=@<;>q*j;9HqObl%3K_X%40Ny?P?nL59ePbalf1s; zykR`+%e0II)HV0I%?TrC5%<_b`OaFz9!_0sTbum~(zTW|{yk;FY7F3u$qTEtS<5@tPTEJLSlCf`|l%&rKH9v%4Q{By+pOmtjxuvWbZf>(N?eGSB ze5^Uu3EDw>)|CTfp4Ca}b1vkl3euM|$8MZ)L~;((i}S5d83TKHmIWYAFHa9)rX9PO zNzy3#8spb!7W-s&;`Yrk>SC3Vk8%KW_fH{1eyWCrlGp%Pb)ry9nr7UyD zKhdirq&MHNCVRs;@P@g;Yu2i7@Vz(q)f-8Pj74tKVeCa+vOYk^lI|wzX|h#Y`qQ2( zT1gpK97$&7#}DRmU(qkCSqEufS4e*z_a%|r7_%cemm!=nsfPIr((#}7dCYN=hOsNX zRoh)d8r8Hk`*JR`p7$=|%T?H)cq89ff3VkCPdbrr<)9SqzMydOXh8n!c()vW8sv^( z&t^4qr(}#Hp;lq)ei3s9A7iXToO+zKWS8`w!MrD&6&?4-3AMhUudT)NF78$4M{hjg zq|t(RqiBC=*k_%?IY(v6KGxmjDMtRJ1L^I#teaQkJ32qDcY4;jCnY54A!&Wa`PdJf zVIGx=*gF~?WABs@0uc}lh0GzWpO+cI>}#ZF4L;pk!Wl{~#zOX+=wm*zLy>Ptt1Ztd zH~YBhtxoPjEez)uT zIA@xq*G-(w=l1V0ymb5PYrXHHpQ~~1U;5k#TKesQPvh6+!G?*D5oSSe(BX672j~Nt zVG2xwVW8uVga~Pn{R&y!HE9e_bwJ zzDbZ5w9fiomqnLTmsgih>!#D!Hp-lk9@n~D3-mowzuP-LeXWvx22JDdb(%VDt#?8kT_&BU zwwo@$w!c5E`0Kgc&!s)EgAx5BGA)udfZh{|X6^8XeW2(vP!!4m?dT12`)Jkz(e$xz zp0lq>9~+aGd-~uv)dTOmX07q+6n$Asi!*=gL;S5jdi7*2G!(z=#rQm!GV(nI&kLIE zWU19lGT5#8#^N-6))4xv4)TpT+ih!YrQOV9znMK=^CsG+D|#P5e}D20di;GCe|zTJ z6XwwW3E!QtHhl|y_!8y{`TrIDy@|HXJLqpM-i5w4@STbN*5qCI#)L8XEu3jD)cDs2 z|5sIqRUTj{fFB&tK`M!x+Pg8+>mQknAsWuf7Z1vu75e>p|P+@6sQpzYW4( zx{ltJ`a2<|zt!@~zb0>u~Oog0h5J`rDkg%oQ|x{=sMD^a1~JUi3Gl@vM#inGPq8|14U!OU}WypX&7dY0_@|XLNeq$C>b3{d7FyqhI-V^|JMu zx&CfW_X%1*{f(UNr*wPQXTdr@{aqXVguh=w7yZoC>r>i>Zj=5#if`grBSh#p3I65}v3H?a? zc{J;{_8QhKBzGe;lb;Y^-AfIJr87$)fS|CdZC00Y|LgnsZ}bwr)%#cZ_x>~C`@H`}CivI?kepg+-_~cj3HI0RM*A>(CV{he z#wYg9bNFe(o=$a)CLH;i?LHB==A#cO^7KlBgUiQ1T);376#ouH?z5PuF zTmE^F`}99$T*7^Zgnl$Z`qTf1dC}YOgud)wq<`Gf{l6Z+wEWLG)5G|=Q@o6O_`lAX z66RL#&YAT0UdyE}^YM+yLC9P2K2twlz85dk{oR-Jx7~V-Opponn;_q|*@U*6Fvt3r z`IUd3ia!4Dwe?&~kA-@S{x4`hjwc)PI~WE(#)qx;_ZNDM|2sY141Dv|XA9cw;Y$YXs|H6CCi*OZ2?u-&pVFw${hqhBwywxHfw3^53v4 zyO$u=?ibe-Ho|5&Z1;2d4$m$4wk{Iv8E>zIawh1Tpie?xZ{Pcux=g4qc8o#eagbW?!!y`2=0?#53L9D%9Oi|B%9}>o()ODy9D!`+%n2Gt~3-z$Nb|j30S|7h2tk3-Whk6h3 ze}g?nz0dex!3VS-yu)y=|0~9exN9!ELi{u1`H(C2TtrJp#Ft4dA4l>=4FdVfkSF># zQihg>BeL?eum;+8ya%gcu=NLLx#+hLjE&7&0_uddTdMCn0X=2chXhD~8q#{Uo$e zXp_*-Lcb2(5V|dNU+A&W-$O5kUJZ>3eH8jUG$u4I%op~4*au-*!b*fy3ac9Sd04Zs z?qOrYehOP2wj=CP*xj(l;e4nZ?g{sWrwC6Ko-sUgc#iPg;rYUght~`r!Ovzq8Ioj3 zo*`|9kPJC8RLRghL+eZ#KRS}-QI6U&Jvlh!%wp7qjJb}~C8?V9wGJ|;wkWDUs^QYxfO$hRTGLS}@_33(bS zp{YZ|LaT(DZ$5PCfHkI>7Z*FqnJJ`H^t8XG2I4%SQ=77&s4%~zco{ahlGC=p8c&gYsXtN**n&3<+tYT9JO*Z&e=TI zwMAvHreMwSi`Ojv3v1?C-s+)&H6<<#YsO$r9Mt8k$GzoE=kE0;arf~1J%!V9l)%}e z1aZP0#Mf^@d|eUr$mPu2ec$&!9v(!z=(vsEEpZz-i&_`dHg2u17*9D*SuNv6z}HX* zI8l!)359_ZtGKNEvab_#V8@cQV;|q`cAFEc2b}3WD02VygF^SGJjiov(*3<6QAeW= zM;(mXAGJ4XPt@+HT~RxuwnuFvd=sp_**a?F%}=A2L@mBq{bseB)$eV)Sxw|->8Q_d zmWZl)Gsn$rH_7W}#+yNrF_AAKZ%5vWycu~T@_gjk$WtPb$0CnJ9*o=>xhisHWWj4W zBC|zijSPS*lb#}sm+SCPTQ<-vx1*L{%lW^ z-A%Tq$&j>VqRhU;-V#A&{Ow;C{hfbCG5UZC&;`DKha)goss{a z%Bu3|3sp=tnv_j?a`56XAm9p2x(zk5%6&v^gvo|VBe z#Cy(r-h07&(R)dT$}sO`?-lP=?=|mr?+qC)-+Lc;A9^2oAA6s8pUMas>3!yX?tS5X z>HSMadAG}G8ROk4V||%@S$tW2*?if3Ib@tKr!SW;w=cq%$CuZa&zE1u%MZQ+zJk6& zzQVpDzM{TjGC?N#iu+3VO8QFqO8d&lB$@21?W^Of?`z=u*w@gz%e&h-@9&RR%NkiL z>twxi!Kp77<&yKtdF{M$qMaBg)`@dmxhz+l48am?1gl^(*pjPqE!YnBcn^6aeO-KA zecgQBeKmcxe06>GpSf`cS#lUUG`m3g?(355mnT8 z&3D~*!x!nh>AU5-?YpDO`~LLZQx$x7RYg@vRaRA0RaH$@_uW@DR83!$?}6{3?~(7Z zs-} z&wS5)FMKam2h~w^^1X7h`ChBezBj6iFWMKQy82>OH`QJB@WuK5QaydH!xYI;j_FvA zt;a&g;{>U1)gbkq8ti!05H(Z{b9`#J`d*DtBOOPLa)O;iYP6GBjd9*{vO7uCR41vL z<|K2HJ1Ly^)pRvO{p5V$KohnXMrTJ-AJ9TPuf^)5>M#cG5c`&PHdG^Rx4dv)S2V6|f3gg{;C> z5v!6pOI=0@<2S_ zA^Fal`Iqo38)4qy$GZc`s37#C-rtaCf$sq6ZA8w)Wy1CS6}SpR;Tqf`oM*Jl0K<`Y z;1S_Bk&ok{{}(-Ld`UQ?sW7q%=Z5r8d}Ic(g!3CUiHnDCJ%rhgk%VyK8A$`se~CWx z*U*!RksLn4blA?w96-h(vjm{06N6F3$U~g;$h-k$EHWQ3D*N<%MFPk;BGQT}A45sIy=j`6ht(5HdP| zm;4OIV8f*>UE*Cl74d_(P7P@YuZiURnJ+cPhwapdK>g6$iwc2I;)4nU>X+VMSdog# zPk1V;i8KTbyE zcA8=z!qJ~EnmTh7z6&IV^zh2y%D;g>EKoz#K_=k0SA1 zjqe0Kefv%$DU(Lei%iO8QXbz~BxTZQyO@-VRjv5WBk>K5 zwv#zKfbSx5P5@O9IX8gs5^{b3RS3BN7Lv|oh`92-oF` z2AA+Jm?Pq98Ye5#2;d_vO9fEvkY)fMY3uo>hA-YY9tSUaK12F|2BkV669w?SLM9I2 zWJA6e!1o%NB!KFSOd7z4epa#odTz`~g;*&_AAR*)R-?KiKM3H9MW%$*gm*)x3E+!E zrVZeu+*Y~(sweV8pbzj-e!e&qD--YbLVgs$@gOrp1mUzfzO3})1R?W60m8pUVqc9z z`8gdE3%jZz$f5xpZI5D5lJMckQUM$XSvr6kg)9SQNeA0;isnbrek}Y+<7oR;2*3`O zush?&(YCAvwMl<0vQ7XeJF;#7N81?x(CEIysvp47_HGbB_a)ZH@F{s|+c$zH#Gj6A z8o<%^{w#o#1NnIXN828s~_)4U_=)_{6P3#>3F3(KD zk0EElY{CyCwSG$p{}s6mmJ?1LTPpw^9on?D3RZKi>v;{Ji*ppY4z}>_1?1KM&OW4m zXFK7M$Q`hg_{s4Ir&Jtc6c`g87Web0G!H=VT zLFWyQ_K}Nlm22%6*WfzoJVxGtKMAjnyazA1*7g4qXdjN&>lM7_x;gR<#PaS_WE{AJ zqn9lK6z|za0H-BVK~mzAmYpnsgYI^6NJC%aL8gWD^gkt#ArL|Mdm?GEXIjc_hKc?Z zO46g7$+Pq^K)$+N5?w;b&&iA=uaGRHQwEt8vJnSD@cWP)gttNF1k&IHO+xZONy6J9 zOF?PU$%NGJ4Rhse(Y zBqFWQX7DxfF-|D@hi>4yBoe(tw{hJAxgB<+Pch^kz&8{1LmmM9Ezws<>NWHvaY`e9 zh2IGujQj&Gay=Y*8Lkqi9P%1O5k3a_03H!ec|x&CD7Hw1?LuEd4A(P}u@FZb%1Y5C z%*S;#qyz7B{V@_dX`EBYltBGj&5_t$lV|~wdJM};IOPh<2lkh340uXU%Uxw^D}Sa+(w!K zIKAgn5bzNGCldQJR{fCP54Ivbej*)9Dwzkgl7lZ zhwcNya|h6UKsdJ5=)NEvyJ~cQ5MDC?Uz$sJZ5Tm#jPNIu0`Ln;$$*X;{@RLUND_d* z03;cbL2}wW`DREPz$V=c=&7+wAkjs`UlfoGRRZW=17yGtG<@YK8CpSWuFLSJ(I}tB z#wR~I62LAmlI1o~Zo7g=j#_}Oww8^7y0+_xPz^ zJaTpb59L}cfIoOB%i?hX5-mmI8;e&Geh|3^)^bffF8&K#uJ4E}#kLv`^}IX}po8ZL zlCmtPEPUxM52^Eq*fEImyxbcghM z(tmF`JYlaP4Ccdg{s!G(xFM2^vL-|KWayThHj(^O_z?~O@lu2Ux}|6d_-l#4NSCGdq3(?v?=g`Y)Ak$0(eBBjG&wMdziFi)gxM#v95D~HbIC~vt_BIWU~^4|i! zR-r4L7pa&VCc;&bO4LiGslrcBfajITzY29-<)TPc`l71Xsaggo2KAr^dB~p*}T(1}G6{(*C_J}mVb`9{mk1L2Y zObX=j$p^3mu0u-%jY-`3t~*I&UVSWR z2!}-a@?PKFBK`1}e#3!0`hP0?c|o9`_$mcVhqLgP$k#&w-M>i(=r9m_d`o_V=yL|m z7x}Iy+llYP4ERH22zDNVzYTfLcH%HNDl#lDpv$l$;ED`y0L$Q&$oGYz9&~^oU^_f! z3o#1}f~z7UsrQli$VlRhoC4@S@&P{`^FnIK3Ppf)MzsQbY1H?CEk>PyYiuiGyQ@uLklM|4ifu z?EXVl7y%mq-6v3I6N&=1m@pO4X~Hp)iD{t#d<^J2@kbz!iI*Xct;QTs3D9j)Z=kLw z%>&Y%bYEmLc}?yC%K@8BroMip4u5J)Uef@Y(WC}hq5erxAY|Wt?6CIs$b+JrdA$25Ha04`$4QL*R=1R0zoD zrQA-n>d=lMmy1O=Od9_=(g);k=@u}_X5C&_MpQa zp6|g&_x2LmNBaA^z*CX^-0!Cy9w-jo;V4HL*!JKckwfo81)$uAPKq4HeurnneUT#> z0lOX9C32MV9_8JmQ~h8i zyb$><7m(&}*!y?v`g>n^C~}%Orzyvoy0C+zl@hR+qZKcd0rELl0B8&6DffBmoorj9tfXGBJkCT7WzDe3Q zqdBIj3A}e}Cs5|wynnk2M>SuG+|3TnU=qZzrQQxG^SuzL45W1rUG66X>iB+HXaviE zw4=~B>T8$`*d*#tzGR@CKll!=FlXoeN7V5n`iw{40CsxpKn5rVGvEcsL)71sdm>LM z^V8EJ&(P~xIcN;afxMol0P5m-d1wMRMP5*j7d(GKx-ZcCr4PcPCq!}7G*{$RDLBAU zQ*}VT!5(jDgV7ZMzl_1ZW9D!SWdY@nby+)L@3;uSE^*kHzYs0%H8JEnA;49c5#(VtL==W}lk)%Bw7b9s1^oO;uTll~V zNIx0zlWm0;9Gls|ee&C4q^J*szh7I74^qQ?h!P`ZK^P9V#9+Q}q~dw18NfTKNk27Z zOT(96X;J{XrWq-=0Q@0Fx{^>61_SpWR)(Wuqz{8nU<~j*PDlYDpOA5I z2=0jynj5fn=u9!fNIz^YJQ5?k3Umi-njtYv5F;b{XIv;ork+4ud{hb0BXee$E=CsW zEz1-*!?9pe7zTI5$VOV(X2A_HvWLS&;5tVZ=mZzV$mxZyK)G`fo@x=Y-AbPMU1>3!d@}*)e<8=`Q)eW3)F{0Vict81+R)xs4YZ_ zQJDHEj7~+e!S8UNqe&A+LbMpg9*9wVh!`cvs|5L!B%P9!wd5NyN=*`jKZ|3O=Ka!f zVw9Q9Q6@f97JHRNSLXdjIr1ux%_>kg709n5X;dl&*rRe4pq{E=zbf0rsEYqo#c!(N z`_=H%>XfBA@6@3DHTnZO)i@zWP3%&$8IV>@Y+S1$kVh@js`W~Y+JoV#7u_wE2o^)E81?bv`j^FMfL$A05aVO={+K%W_$PQMM#C1cQ;biF!yGX_4TA4r5gZ15 zrV;5i$_h)81e$;ZSk8JEz<#h+;Tr)t1mhO;jOS)E9#}S2Sx*Fw+VxuKz?n> zw=MD7eJMtJ;vpyy~iyvdio$2H2r_1 zFYlpK&%0vuBHdm&pg53sFYML}8}u3l8{v`|y%l5y^6T9TuvhP+Vtknq8Ua4?t zMjvd|Cj{`>KE&;dZTj9}d_n`=2=Mm&Hg7A^l^T@h@zmKF0qn3*?x+a_! zW6Wp3dt(Oyb{NO~xI zwuv#d0PxPV7Vw7{(|Kq55Wp{||0>3el<-E3pU`9GIx%LU<80EOy+DjPq%~)s7;~}z zT+)~~R*d;MLCZ)n7UY4Iuw9IWg<&C3hDF$K5os<-1ZAKXtbv z7%PJy6e585E87BbS1yL1fp{w)fh)$UBtYC%5rCanW4kqD#8@lP0q%;iE-ldaY#@9C zW!~5WX21n_DaI!B-$XtBTpD(Z@eBU{OBN^(oq#^%muq5dCY{aYfOI#12l(|Cd~FNy zwse8%a0Ft+*h-wO2Y~Bs`Jo$N|82L$*p9y2@yqQ?#n_P(9*VKE3G{?f@T(ZRXnVVA z!7#R2OTbJxBgUR_fN$)r2Ajm#mmO%I`}za^wI9FRA0@_tiEtP$^0^EB)j|B_kON-< zHaSe#Vf^keHa$XKM{2`ppiD=eiE)&=KZ-q$wu6y?PaOSCjANAd73PVeh-Jva8-=cw2#x{ zVFz4+=VF|h4O<~nj6cx*kFqcysK2ux0(Ebj65G}?9(!Ov5-iUFL z{4etS;wR7#XuB7w-%Htn`n}W`u+ybka0qzk@(?%)*8%%n2?FePg>qf#1JutI^1Biv z#??u%0Z8*&a;PE3^@>2f-1q>h0=ly%F(S!7av`AO&EaC)@*4@(i)YlyvqsRJ&z@>RUp{@B3wOnMH4mu6*B=A# zzy4EzvQ882RgzTQJ!+J1`de|8Y;>g3Z&_EMe&W5^8F%w zI|@yq3+xdUoESR5Mp20p0r3)zg_ENA|EE!j>jU?RxqmMSREOcP0?6~dI8jNmKouAP z$3!I!f~?R82uq4S$!sVKJz#;TlS7)xqSEsJyOZ{!sC4L=?v$txdH2I@qS7~mouWdx52f6p<6#Nx z5*0>S!mwf3K~dp3p)q_5^I(gp3=M#^GE&w|1)v7Bg0Em9pP{7(^2l6IR2I_CvJ}pW z$~se2wlXjk&^dckI4&wjQoxouHUsJA>?|r*F!X^~QMuc~6HyVQ8&L^%i^@|Hh@ZC@ zpi@5X^I@a>q?w<3El?M*QNa&k47?OoXr!pZX<$0s7F8q{VDF-&TXZ5U2GT6X|4&h| zj{$oY+bgPgMIevje~2oP0~$hKAe|CNMU^CONpvoWUzPFz&q`BorTd90^8u_ERhIIU z?JBBVW;h_KJoYM&4Jy=x)uJjEg(y*#sOw6^ubdHPi>eX^y+l=|PO73SYYSBkf2oF@ ztET|sSI17((ZBkAQ8mH=eQFGW^P*}}wwi@u5a8pr8jGq;8EUtIXQJxhgLS5fs*4_V ze-%})IqVlz{~J*auw8>ya9b2>3-vMYH~d=EC%pSsFb;kl?D z=+L7lV56SI>4|-N;(t9Ud#@nCKYLOB-Uc**%c8!F0BrXqe%2=~6oW5eJsbu4lfGSH zwy1vjU=F+z)ju6ngWn)p)Bv6hXaqls`YH+FA77!<*W~#%dVWK?-z);kFfcFBHw?rV zzby-g;kBqi`JpdthbN-GD+-+fe;Dk8aOe$xiW-6(f*%a^KszALP*>D2(i`@S&((r~ zx*R?Qu*di0|2=*%q72LzH8K@YmQkr;ov6{|Gn#rClLEengQCV}fgfPAsBzeG+%6!_ zc=R7nocfj4q(@*q&M{#VE<|4Gi@nwJsq8p(ru?I&tp5HtqTozL_6=R_@N3p0VR1;ksJ z46*@rwD2eR84kj0QH!YmMU-_>5vT&#d(mZ4i&MflK##@by@WKDl!G2XKfi=BEO{wv zX;x?gqhJ$Ij%BH#I?yhbErvftE%!lj=m^+rIr%fkS1V|DD;mNO*Z`DyWh$r)w8NEi z;CI0GtBAX*7W9Q#KpLw^V>Q0Ex(*D4Wq=LVcpxvdgvqc69*A0-4k`ha9`B=5FqY)^jJR;et{dJHoOnzp(kLk4cKC%3HgCK-1r0Rg{Pu6r2*=A z(*RfmS3jup>5y%5AU?Py; z7V_JQjkaRXt-}C&ZpEJ45&?C;jkw!J0PT-+1+_gfP$%2J0Bp2<2VkQeX`vK!hq-W4 z)J_Ai(auj{D3Hd^)1r0}zAFo0|6Pwn?YbM6w1NJ{b{hxR&>LhkLNjv_vI$Vb* zqE1Z`_1j8Ozc&NYIXza?nF7Fje~|VcJ>h_;vu$CgsB_rn9PgjICF(r&bROSi{;w`z zn+wC?t|;dI>f%s9Pv-gR(y@4`v&%Jrdb*Mhcy@&}uSAKung%KX`CXk4l;6LS^Ux)bCB~ee<@cTS0(LZehP$lc@^soU7-Ht*c-1yf)TV1qlsKwfv6 z0(QBx0nUoLTM}YK{TT}7pfwDGrEm=JiF-+bc=tXA>h2z8yGPmXQHJ~IdH*AzTv6Gf zCeYqkgQzIc*(uZwz?2(aBV>gic;Al+x={pig9v&>wjA z>a?iWl=*c|XavJxJzNv@hBV)Fg3&4K1bzT45_7E$ zgac!NmB1e09Po$4+^PVbfkYr3!2NC*i`!d?8Ssu=LrtJ1FaU@JaE$@i70J%z0n7#t1J5Pq;{XH$0|5NpXAAHJ@Vmq+V{DZ{yUOUJ zavpF1fSgqRTVho_0noh41OVS5=g6wy?^Q9Es(k>gU)4hZWUiVQ&uP?^yi}Ctmywx$@>KJczjH^1vTOH%|GXO1t7+?)>5qKl98oodm z0Bs=dz-pkK8hd~n0NV10&hW?g{z&2z_)-Vu|TvN*cuoC z%m9`Hy8w(a@IHXHYuW+TfnWf%sEPY(L5I|u3Y?QzZFitIfO*$`ATi`dSslo29q?0~ zk-!uHa#?2uuo*ZEoCWSktS;oYZXKWvFc`qKbr%D;u5K~#LSpp{0BBMVG^q!g)PsD~ z!?@~K26_XFfK$L<5(~n7f*@Z(sQ_dz2(lN1zc)Z14SE78z!m^>Z2-D91l<~fZVe{` z3xV~(U5N#&0KN;xJc2QgV9-1m@*Mn?#6lPl0*nL}0Qh^zJ&8541?mF0zR?_DKX4mB z|DpasUjY0Ox)!(slu0bC3eXCO12zJnXV{MtGlQmP^lip^o0kFT!+Zw#MPiNpfQ|sx zx-r%oIbeqTFKdD^HR%UT2QZf=xxjYdC~yP7IKpMX1HgE~LxFYx#uYvqNC47+RlrsN zV-NpJViAsjKL8$&z_k$>z$xIB#F{z-fj|qOKQI}<8Z|u$fL2X^l~^;(u~|1@Hn0!4 z06YZ#mRNHqpbY@JG)JG!(P#4tiM6N=puHC0$rj52@MMdd0Pbn&1vCdH0$BiP(DEbz zebTB55C)*XR;d8`YlZ$=p}$tRw>A1}9RZ93<^tg7*5`pgCDsOf-UfW$CLHJmOaSHq z&`E7D*S1*Ow!?uO0ByF#-`e>ASc`VkfXx8L*v=xc&oKVaS_6ZCY~XX?K7fAOR|UEN zSljmCtM;3K+rV3ib*Kpp1(pM+fG5CviFI@X&}K)p*%57aj0Z9R+>82J))Du2{7GV+ zD1bIP4FKi?So==TB-R=0)EVp4xdjjntOgDOmjTeFiywe_bb*X@Sp!@IARk>ZR>ad- z*Y3brU=ENAlmbsB*3A|O1<+r&nE-gW8}97}KJ9J*ngGLr1ORf~9W?4*41j05|17Z{ z4Dbf9o;{*~g}`0_-}iVYv7W9#Eua-J5Qqa70egTO0Qj>P?(c=~dtrRNmH>wV$X73n zuUDDGdSe{D>i}(l!N3$?B~S?51F&9we1UercmQqm0WbE!9Q%9;U@m=SpfV5&bOoSK z`>p_v1K&%mAHMI0KKh}Le(0kg`slY9*bEc{;J^L^2n29{e|+D6HE;^}0l*jrcmVZ) zb^!Qu0PY`vH5%|WfbR$T0Ud$K0O&MuJ%IHc2s#Y>5vY*ZAQKP-3;{r=K}En*i4ArE zngM8c@G9VQ;5Ug40sjs`n?u0Ah+ncH-$-nzBY-gsodpyEzesGDKQI)S31HmAFmJ>) z*|2vK8}11-0R{q@0OmCOFNsBh9+6Q1_$Bh1#G)90IYhMqMgpn8X5cLFRAM6-&=`mT zwgL|%HWD-$*%e3wN&)dVi^N7%2ATmwfmuL4PzpSf*l4sf8tshk0pPyTJAelg8zTXJ zKm^bez*>)42OI)^kl0uo0N;)64NL@5fwjP405)OlKN1^<`^RBC<0b)+lW`XT$lZ9* zeSBL0Ycn2yAAen96FATi7zSW1CzJp$B{tCr)CWET@ZH1}z-|Czk9Gtg$4ZmvxxF-hp#NZy(cd!`T6N7tVz5wn6;-2>sn`8%g0kwf} zpc60%m;lTGGJrL}7r z11I5{tw4ahD|)kN)G)fBXm_8#n==-}w8$pAws52UG`e-IQLy1YjPp1~>%Z z+9^+f_Y#}x2Gj;x1A~Bg0P->QDgYi$z&sNA0Skbg0REl;y*RB609l@fHJAojnf4t3 zIhu}sr*{X&0?-xHj{^54mM8SFEXfrx14DrXU z?CuoFR&tP>CCS&<)t9*v)Zj5+5=wkoO-oaHE=>DXJ3$BoRMD2nh=_hZ#NG6(xW)+_Lke)}4emsNb~dun4l2 zd%WKj)Qr-m^@AdCl#${w%dT{rVk2=3Mj}i#m`w0HO=MB;Nj=hk6F=lh+7?3ov0a8= zsG6iwFG=EM=+IlLDmujFe&!Is*AT)&1XMpA_-XK?XW!>6UG=MjcLsX+t^$Wv)6;&~E{6|q#)z2IdU=C4?CSw@$wVPn+ywb`3>w|&IYpz`8 zeAs5}sJImlwnK?qRx8!q7Qga@u-VCWwM2t@A~9n%MZ zPx|QoU*E}r#6%sFvTYRS!dXenZ4}3&ZRB<>+m5!kRa>`dH^!cRo1BHe7S2svfnSH3 z%WYbJHd6nx{V03O>ya#Oqw_LhcOX)eB($PJ;bs0nHn4Wl~=I+^T zmh9(rS4!K(`?QoEQR2_tJBx37{MCVvYY$Eg#~bGtVoE-eztm8Y3?Q&hXOp0-s^b44 zifZx;6f=~KW`aK|MuTE9nZaoRe$|!s&Nt%gbg*&wX3N3@Hnvw+yc=xV=)ETYi;nwl zl|Cms7vyMv)H!T$o*iq`#C!Ebd!<*~-mzrviRE3o&X3!AnbX~K_GFLHQWvhR*z;Fh zI;W4jvZ-W8mE_duEcRWW(LrN-jBnWol>vB*g)dp8fB^-w3SOVqWp3Bya)y>mP$(hA zXth}-C0cS5lW>#FCWTUyyPHW3pqNCO?_t6>c;`Q!K_`x`xBZ|Eb)cPpBt;~&dvb!d z(DJVQhIW2%>{L8i&_5Ej5Ea>4E!tSYd#%u$LM1g2tp?ISv(e2BB%pqN$Fz!dKBWJY z`c%FW6uY(~XAZRE8?CGMWw$AW(un6@lD#KlyJ;3}=dmbMAK-05!&wGoM~JGwS%$Ru zn`DE^SRk3J{oIxqLvlVNK?d#oin*x|EN|BnkS( zi3T(Z+tRQlZ5i3T`EAmCL^B>SqLt{VB9$%I^^s)qBOxJMSmfqe3PPCDxQZWn9r?24 zD)~y13}L}A+@udoMg?tkiD8P#4H9f7-yAz;Lv3p`AWjcX995aEU#Rw`(22;WGxt`n zgWspp_WHYX%ded}ye4K6Ec1VU?%d&L?WlH>r6sk|RQcWu?cvmp+CQpt^9d&K4pZ+V zABEzTeEkfv**}C1Df&vARh9Zw<5$yh^npky=f)T>N}fV3n~BcgLdmGj>4$+rKNpop z8L8)poonpXIwv+LC%T3vc-3AKybnLTMS=NmK0f*X?=zq8}?-Jx0= zG~WpC%JN0?H9=ofu#g_T@vs_tQl#(FmeyCiE(5VWfC0=mfM-8RBLToET;@LNX*wATY!z)bNK1etVpL7Sp z>fo;Z{Kcl5&Nja7NG=K2E=29BuhQTVt&{e;+SQJd59RaUe}d|nc`x;W_E_Q1&x}7z z5=e$6mQEeirf07;J&1gA?Vud!1t}kt%f!6FNQC$aLE$sXUtVAai%lg~A~%2kxm*c8 zkJJjQ9R|H>lKi9~TniiZ?*hY$2?-Dj54&cyV<4E}lh3@S?V@SJ2HQAmPrfMq&e?uV zTDQ(NPDDAi@2d8~Au&GrfRjVgYEST1jV2ShD)mtTVjH zsDe>o-@|GI8pB#pVSt75HyN3^)3#nyHg|S#O#gQNz6&$MCmO%PH#Y?;nFE~m$$dFfoRgq94)(iX}MSV+!{2C zup%vOnKu72THRXlCp!hXuO!t#tHOi%C>m-Qghn^Bipuasm{D~Hg#$<{$H?fOvs@hd z4IY!~dc^S8!5zn)T#ILnFufJ-Tr<)%C@6xgo^l|v{p12O5L^Qu`yCj-DO23AzR*B^ z0X1l7fSUv!7(wHLqWX%ðKQRh)gExwcpiZ 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ĉe%!;5Rtl?e1(k+iJ)SjAd49 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

pHFTn6H-V}r_} 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%0A^A@=6Tc0r&i8P$<)#6uVbBy-87= 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 h?Or1tbjPhvc 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 literal 0 HcmV?d00001 diff --git a/static/Roboto-BoldItalic.ttf b/static/Roboto-BoldItalic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..ca07299c150daa0490824da66d72ac2710d76770 GIT binary patch literal 312608 zcmcG%1(+4b*08&}x_i&wdj@wK!QI^x2pR$ech}$+EWsrZJh%sUCkgKE?gI=G+@w+<)D%S?@0K%9=HJUYPiyotkxQm9R*T6kD;}C(@a{Te{ua>blFt8nxDqKOVA`<@i&sfO@PS0=LvFZdA`cRHSZTkosVD2-JSA# zMETwzc@cN>sPiK6`@UcNDM$R0ZZS6KH)8+ANucAzNho(DsWg;;nD^q6ou~xj;@-5z zscmA5*fZ>WBpKqD=4olINJiuTcT<#8O~M9n7p6nXSFKuJUpbCn2X}LojiSue&#a>M zS_$QUra6Uj#{4rrkbVp*qhwMeq>r^sQd>VtF?+wPx6?|nQCWJcz0yJ*aHg4KrKMF) zavIN^QD%_TSCu8JdhT>4er>o12Bd%lPzI_)SI7rLR58h-5;=3tC`oVi<5`e|nfGL< zD^il%Wt?eNv?Q^ErH-9Ml2~n^68ANvsXbhhs49}#YD)U=2rnr~To-sY3|dQlJJ2WV z>G!RZlGeH?)bM{$qZy4vy&7t2RU8UOgU!d zlQ>pete;e}S?wgJRa|nbGg8Uw?L4=dJCQ1dBv5gqKU%rO)Yq;(#BJe3Ssf+2)z;Z+ zb&#AYoUj1#sAW>vYA(ghx6;twA>GX=XSMmvIgAWfGqAHrh??R2YA2Lxs+e=t8YGpi z#m+~&9qHwhG=}5cu^u{i%w=-g6)KI){<774D8;SnGQfBL#E4_Yk=s@QiKm`Qb!e() z%NFajbHTibotw%u73`cP{0{ZK-F)c0wP(p5`=zXRRh2R3J?BC|EoXw2MN-%;B*@w; z$*pIS(lu4Q=#t<1UJ6;?Nh+(Wv)y_sIqi9pUS*|T=V0H)l1jCc)b;>LL>vhiE0qJh zQdGqekF`x|yV6N_>psu0rQKM@Sa)S0b(+auD0QsalErQ+p{|m?IN5!6{?2i%HqL&# z6aI2m@>naJ+UlZH!Cpqa7m`h`McDolKB?^pCz-) zk-GK@WM0yyK5XqjCnY8Ik(hE^w^GSK>LrKWU%pc}q?pe~CP)qIfE2e2@NOolVb{Y) zRyl{YpID}I+fMD=gpbyb&S@)|v(sAbytDSpX#BDa=~_A;<2r5NHe7Pv>o(*mCP~~I zBuT(0$%cP6#ee46X`GwZNavor7Jgd9Ic{xsKA7+69bMcX#@9Y!^CJ>w2as=bC)^Te zxP1s;5a)y{>evBEq^j#Y^-v~y5w@&rC8b`*O9*8sY$@jhI)_^!GQj*O9qroALsuB( z45mG48x(iWTN}ktZ=HVjL;2RaNjjw^$SjP%&6W;UFG+~cm9(ZyUMLyU1_G=?*nzk{ zic?1!Bs+aV3ag=HvKmMn`y}n9xa3gBo&MGf+DIQbh>teIrf;Px{$E1p-a(5Hk)mrko+Tjn8Exrdd}AeWrm1DlTiS3|y9#x60l#S=rOemP9DBR7#(d>W zv9d`6YrPY0yRrL^&P8jVbAt9i3)+GgJBRE3g>q)L<4LIb#+hN|q8}W9j@mX!@x5fy zHeiY52q-4G-0QIIOX}pb6n3SB<5J1)BMIz^lEAzvWzDP3OFKxa+au*$v!%4tsKkz= z${@=~K{a0rnk}Rqw%cKrkrqa{%r`5^eB-7}gu{%k3t^jjA_riJ*^9oV7wNW;0dRQrW}>`;3N86zQc@UD2VdWP`+N zqy*C6yrz$Pr{>8E)zn#F?w4z35t*qhr?C1>_LfOZ zel)*@AYp>L#Pr*m-95b>=Y=)>Z{%8JtlC zoT)I`tnExSQy|AUM?|8^z%h}?lW-s2!cM|c!6vR5^`f>yPp-d!Ph6h@-i!PdNxaCr z$eAM1%nPDcF(fu2>?>e2j?53~2=Bx5)m)!|Y(QLJdciy^!L#Pv|19!pB(gCuCyAT` z^ zjPc_@=W&!U@`#)bXMlVn8D1ijz(gRg$VYIQG_)3OYdF7`h^>5oaxOKWu_UP=?gdR(&_Niuu0v(RoP zwe9%Me5;G|iuRNYdEI5wwpPh^_7}9>cJybPoGTQx9pjX4`y+fDANtZa{5fv&6Do-X36R5DPPzv zr2u_IT|Ez=Z*GmwdGx%6{%0rSUkCc>n)WVfY&S*Ug7Ou5r7_9F?8g|ji+RINr>}2( z)bk!aPF|E@c4n#TF6HcSe<8_S0rC@e@i3+)v@be?0}eTJ87EU{TiL^$9oBQ1?P@C3 z>?h)}JIk(szLF^5tt4{UGKBsoIpc34JE^1#XeeQftv#%sQo`zl{VOq7dF~8wt#CG4 zE{SV(<(_)6x;ty_r$~JdX0%kWH__Ma=f1YIrp#u5i`i+IRC4tqUK2iGLtakmuJKr$|kWN4gsp)FVn9!KH+dGMG-$mc7&OF|k8t}DbbQNb#bzBU4 ztC*hnk~!cK>A9RS=1b;D&7?8)mdOr~g}OeuZ_0i4faX$*`Am7zuHj4jnpCuMODQW{ zbo8ce2PL`ROS`H96I=LX%#Dcat&JiMy6FHz1j_(LRB{ zF(0+FGpE^%?%iaZJyn{!QWBPka;-)VBYsBeYLAGkoYbO^FK!oP&RH58M9R;06YAcP zUDiiwZC96Nj90zwUew`3d}Wn$$4*Szy-7Qzv%^k_{YRh!e(DM)?PTQ9o@afz)^nuc zl0nZU7&~*C)3H|{@)_c+rk=9~B*qTQ8Ba6GQf$@0n#_E@ne+)5;hcBPb}k0&rk=Vw zFRa&6fHLN?hsX%V*YOT`&T;bz^XIONxm&2`9fWtGu76-%p!=0$`0_F4N1dcpK#*i( z{gJ}zkI(dHKGo6Z3p*)idi=hkb%^=UMdy>N68T(Y{{EhJyigO^ zHkPDXH)|U2)3$6qpC9h5wX#Y&y9;ZaZS+Aar7z=XJM(KF17M1oe(;Oy)cxRxVH^30Hq6~(C zWL37p;Y%KWZraM??osqcq3FjGWE>ksjjt8)k_w`TA$C(@M)^l^#Tb<0e(#pz& zZmhekGt5~tv$oqVS*_8Mi}sV*YUmuHEoV~OnTw`ij#Ap0OIs*L``T@emtV~+*s_m& zX%3Me%s{EB>dCLFt;E+h)wWVKq=zzODzb!+&CWX`T3Rxml~GZQLs_tS7HqlLxofV( z?zjB5w_1~K3Mt9j@2;wY{TE6{^SX>RH^?}%7BVqw&F50wtPBgGt9)htEP9O33H5-U zDvI%0quY#cOg_go^8r2Yh@1k+Xfy1WMAfDLtIT}~2=&K}YRmO)I12~i55oIEjTo4R zL^S~B7*UU40&$*^PC~9T!xy0EQ>5dYN7O;qf>ID4^gQ4O%;&v3Nb-sz&BzPLyrAa{ z8a;3Ln(#sBx)e#D{n4WT6V}!@)qAI|dIQ&_ii zTa)m&I`nA+ombXjXO(eAb{Pkp!^UO&c%~et4c;?FcB%K=Con8^OTtML49oY7=f-<^ z37dHLo$0W)eT~z_NX0BrS?rfIL^m{7S-7Sa48@F!nUVjW&!#siM<}djjb2}4)n^_2 zLMGa8rH%QegqQ=JYQ|MrPd;Ofcg_Z5nH(~6%NE+}EHkUK)+{YYtwPe!!Vc;j>yaXo zU6sXenOoS0B#-h)tAPHp!c$e2+pA@fYAnxLQ+;5M=Yx6N>8N_LH`B~{VgE?Gzs&sm zCt2u<>vVI)l^$kMr?p*#IY(wn zr<)nhy6p*j2m_@R>C~{N$SU)oQ|CO-^C9QK8rTH8fjtf9Dja~9W)A0) zy5nQJ@;bL+o>|OUZ&swQZs8m?3pgF=3rCo(oONbZXPvRz*=OhCx+OMl;mk5qIvZ4a z#^24-gSl5Q)Y1DejN_)Ofh2TomQZ(3#=$C5z;%#5=0_=KFJSy-f5}_kd1mKzHrSV? z40}|~?ZM0;Zc0AVsAtWWZ|&-g$rstyB$xyqNbJ-r^JhWRoPw;n5Jp6q# zZ6MH4xo5Ch!RoyV>X^2xPMKDjp`cQTj`mBy|!$TreApbGPY zIWn4g!zb5W>BF33EAzHqt|iPLH_1BdihNR4=_}i?w=#%%Sv}UmAu=JLzD)3RmkEJC zb6uY2@0>LO6`eJn=FCT`F;`2AzL}T@ex!d*MgN)=dlmr~^DM?umq!}AlSyN5My`|a z+~usnx7N7RIBSfLG__E@uO_+B*9=I-oT@Rqu*uk`Nya*nbpf)js}FPZwuCR^`icx; z?q0%f&v<^Hd8KZ19VC-Gi+rWZI|;3!^!fdyDr5I$_8k-36`V!uK0mx1Ce;)tSs&&LK5{CO(1Z2^donNNzh1dpRFvjdjVnYh9AF)*2_;$1lu1 zZZjv?>qOag*f)%3UoD?_%reewm!2!?xls-3Z!UhM_m^DkEkvQW-pBk(=5zgvwSacL zRkpagvxk+1a_V(bZPL5WzCtz0rQSLFn4@Gh-_Zt=F}{_Qz3g#?ksf_cRC}ld1L%AH zgdtori}Z!*`PK`r%Y*KBwbcFc_rRJ}uVsDxdPm|Nh9%q+FY*ww33LM1ic!s=CE+iT zba{Gyt*;~FFh{7ZQG=uw95w@_7W1N?tcSjN?=EYIw4pvU7tN`}JtoH>m;Fq7*~6V# z_8@1v#@NFeVvV@%%90U&Hd8xq=nIOQciAIuPyet$R+xPypIMJI>d6hRzlGN3YUiW5 zNHbP%8_aF)(FY%v6{@r}z)vR|&t-yf zTdEt++0V)u`;cmpbWrnHcb;YMHJ3BRHkl*1rK`KEl%uc7rq^t&Gb#n_lhy$l zSYLIQr1mlVznau{HI*y@xwwDMTuASg?{nt))=RUT*E-zwJ>eIez1Az|g8hJb*nVen zKow`O%Wwt+6k+atiaGlj_9fF|TfL{%NwT_FFVK(Vbia`L0fi;2r-HCf`b2;9VHEw+ z8DxFtAIu-3x`Xx^J)h9yHFE+zABd`o)P58M)tCcbV|>1=*Qt7KX&rU0Spm*APi;va z5G`?CbLDrt9^*zf^vcfK-~wY}JE@@iQ^wf}==#BW%bNWxz7x$p=0X`oyZ?fgSOBPU2dql&T&}6Ty3MODwB{TKS5E$X^_ zq4F?K-Y4r-sB~pc!Y6M; z?oP;_V!xq2bM!1eA1KHkMt$cjeOPDLSIpOsIvZX2IA0mVI_f9J zwLSF5tR_Gb4>6{x(bKWz~)~|h*~K|;H(_696>I;D?DuwYF4{vRGyAU> z?QV<}51nvVS84Ct!|BgFb^>d~cg|?mm%A7TOVK~AWq)IcYZl`~CF#Q1)*!}+WQy}I zPYLHOU@{(OiR7mU>txDO4f$e6|xmzVm>xKV-k5J!|N8YOphoed%J>E%s@C zlM>944&gTyIDcqpJq6RLY6m$Btg(*RQysB7N8dCTI7jFc+Ot+_hkmnEUzuj^m3fS7 zg_tY3)whfnBczFO#@WR@vJ&S|Usy-!|4RC?1T$hU> zAA6xS>9-R3_e7&|bDhTzbNF}8Vs`<~;Y!ISy8_spnLT07`$W1zA}b;LBnjzX60*0K zfco}dn^r>l@r2Hw+%Jb5_~=QiAnVDmoe9kOhFG0xXT8|JDaxENFLSWQoDD6;ADa4P zE^Djv&W^xmmvH|zlJSOlyVu&r{Yb{0waC285$M~PYd-A`CH z=eoU7^4lGxIp;>NXoq#I_L422ptC0+7kNzKUdQV|du{Lh;Hu~>WZvOrU-5%go$%kC zJ&b)r?9N<|W8Z4H^DZDa?{RLxp3Dc<KdpBk@v^U*+U?@qdCZmKI_K%vL$LP~cm)nN zPXH;vg52g#8L#HC20O?*8Jym%m$;XV}n^v#6YQ z52@tt!kKoG==b`3PxX=H>VwmrF~h6xIcJ*YTQ_m$s`MU1R%ehtfA#IV==hsC*V5-k ziJkV^9@?iNCB%ghkN{@FWYFO&VKyv)bT9)(LKo0+N5goS21`Mwq2CXIIj{-TlG4}<{%j|Jn_Pu`?*%SKlOvl&pbbPIYZigD3-Zs$sX`S@FE`tvHJWhV@ z3xduwHg00Bn?cdoJat~6b=U7}{dKu?`LxcdLBFr>by+mJyt;gaAQZHX(#597wJz6E zeUH@dPL4@m>!$CuJRBoq?Wk?4ZK>bY&vlx*Y+7#}N9&<=(>iJWw2c$Tq`N96Z(WX_ zgzG$Xxpg_U4T{Fx>oj%RT5lak>#oZao2M@S@3CpcT#wLs&<;ZA8`;H(w2|z&eqycg ziT?BBY^2^Z3Waps(>^|);Ccnj1UGHHNX&f_o@Is1%n{iedcWApBww?KZCbf#qXXy{ zf1ocM!W^JKWBnkmi_;Ezv!>cDOE@3R%K3aw+r?PB*coAe&)#Bsr!8x`U~{|kQt$Da z4()s~-vuOOoTo3Pt?owWOAroExzCH#?O)$(^tFDj-?rPCmoZ-<{}hOa2r3dlSAj`5fKWV~DRM zeYF2O6aB5p=jieHGuZPytkLDt`Td*Jv{oRej{GOQ&|Jrt0C8^JTx@`V?q%&TnaQf?e*DCf9GBFqC8z0>VS~1^ySS9Hv`QFAa zon=0`Cg%PP?TK%Iw0-_A35)ct5A?a5UMGAe^>;!l9AEWG=8duU`r9GC-(kJ>-=)uo zn2UZcIrG=`uIuA}E14@VXKvM9`-rYLpRf4Wj^QzD$iJliUdP4vIkx^@M}M2sh&7f* z&p#Ls|09fYIJ&u>0Q&woD8OOMB&!x;T}KC#z&zVk0I z2l`A0baCeBdp$?;&6Sul>3LHuy8Zvf=lbbuJ@1M|&%-`P+a{LJ%kh7&^ZMp;x?CDP z$BV(&cG@_p*_#N(Ps8lK?6DPfva*NwTrFWQH0FCXUt6Hg^!Tp*So^JSPv^65)3l%X z>Xz@&d~tN2pwFi{lcp|3>9c6go2@zcvTon{J1)K*)8CEpEQjxz4kwQ9ELyiq&cU^x z`r4Atmv-ZuGwF82nebow>3GCv4ISvyOV2}ef5n-(@4GqOCusfjH*&g<(tVLW`_=ie ze$xGguU|nI{mi#M)!(@3@8NV?*5AbGeJcDn)}Q|_WBuFE-xBI?48LYikT$OOzqL+! zztyL&&Ob)iSUqfgp3fOPd!D|tUw1>v?x{t4<_z58+&Z=|^VyfPVQmk6My}7b^>u8z zu`;$D>3nn^zB5(6ZL%Qty}#1d-y>iPZ9AWg?MGtIqmiuD{AbggvFmeiZF^r^{+rZi z^UT9ryEv2gotyKGVXRL7f63S~{tq(Ue|oO%=d0r?%-vJq|FPx&e=1|X(X;<2`S<=a z_WQj5LB{&mzsV7--|%hUHw-cM*X>68aO~N;?|TKlk+3w4Scg?&e<6(izbt#wx}6H= zz_bnB7Jcot66f=r<8T)6uiv^(WKFnO+UqkX_I#@7cI~D;yS~QH7}q>^*?XJBeOJb+ znDIH*zJJ;E@8$mw_u5xu(}p_2(^Z!c5q;|}i z{t9>Qa~~F~``@Imuccp!`&T&M0x9-p{<3wf4gQ0St+#)ZCG|Xrz0rS>(eM5D(NAOh z(OCKS`Ov@J|4(h0Z>n|wug3`AIDoxAn=_q^sp}XS{p5d~GsVuSKA$t`@1!rvx6H>U zAuAw%it(AWG1BFi&gy^jCBE&}Vx;32#u{5zU z8y3P!OV3&U8yB2B)`h4i5NTbAuCM1V{|)9=C*hqvBDy1NfGx1c9^n*&(7);;)}Ar; ziY;@jzOg#R=JnTm|Di5p>kIkM_4xm>USjq5Px60V?tjq#Gu>l-aoRunP@Cv;R-5Q> z{NxhgJG5uNzm!K7h0;(3zVP+$dhCxO)}DV!{jH=Xw(j*f=_C3!_56fA^g91kR(xn8 z%%;3cVT1loQ?Jnjj`24jK|V6+d*3$?dYxf9MQF!))mKh_YpwH()h#-jJ;?dKH3)v9 z*B8F|ddzx4uO0NBt8cBK*9LkoR?q)q_HBJ@9j<-r620HbS|N5F61(=$d!>J+ulELZ z9_*$1($#ynI$gcrs?*kMADupX!pxohd%NwKuak#wZ&dHW>b+O?Z*}_iY4Pg44ZW|S z^VVyRSoAx(E`4+G*tu!!xQZ=&dXTrR_YeO!u*azP8UHKzfcAsWXvy_|MP-e?>s(H;( znnSVXSaXuOz+7i;G0&UNt&CP~tDIHMYGHM;`dU9*^Q`68dTXn7(z;|lwBFjvPGAS8 zT$@JHL`imrTwEG!3f3IIWbKl7STpyEmQM|=Dbb-= zGZJg!pw36jTWtW6D{M@GXNxk#^McKfBz^ zCGv!m_a}uP-Fs5-(bOlo@BZ>=ugK%0j}JdS_;~;0y^r@i-u-yj!Aa5^*qMXT<7=RS^YlW{b!YkvSqPA~+)9?YFnXZ(q9=65i)} z<12Fc?WMODr!<+~WLlHLtx`5A)TBV;=Z*F>*xg`zinQ^Y2W9lcaTgCL?Q8$K=%4*F ziqZ#^15X&{-5sxRnpj(6#D9aDzjp57g$>_=C$?VDE$?C}_ z<2>0tIXpQ%xjeZ&c|3VN`D8p_cjfmK@D%hE@)Y(I@f4MbGRafSQ`}R+Q_@q)Q(AtJ z$)2j7YMvUNnx0yo+U{NM-QLT-{%DP?m36XSHh8aiYsgi(=6&z|;Qi?Rql$}PDa7!nvN5uDfE zWz@JYe+K3@su=S_JD$6qd!GBMjOT&pp(^Y7 zQ+=h%sq(6Vs;DZd%AQB+YgNVb*z?5m)bq^qTz#Xes%olwV7|cos)=eESRk-qU?J5^ zH4iKtSR}A$U@_G~wN$NCYt_b^+4DlR^}JN=Jg+>jJ#Rd3ReSZF>fm|r&Eol>I(j~; zPM%MmNY&XBrMjrDs+%X;^GN(F_Qp|Tym7r*z46pEZ+tb~o4}jUo5-73%}_JdEN>ETHg8f! zfjMff_kcIMH-}oKR;x8?tv9DPmp6|$w|BqVtM;k=>VP`vJ?K584ynWHh&t-c>&>T* zspIN|I_W*^J>t#pE#Tee-R>>uE#y7wJ?7n~BGeu49`9anVQ&#{QFT|{Q}@-M>VbNw z9;wIP9p0VliF&G@dB5_O^_KIN_g3&$^j1>O)eCQB@7LZc-fz5Bz16(cz2ACwd3Sr8 zdYh@2>Xmw}-gu9DPpG%v=H8S1xj}&GHa(`-3^aqxIDy3jO9Yk-EX8afqm{|Z?9J%S zWM#3k2DT1tV`a0lTRE(p-Zb7|?SlHKhIm6Q{(i>lWqoh;X0FlK>gNr!_FD(6 zgWgltA?vVp#5!snvyNLQyj!g|s)+Dalt{dJ{zh-;nNaLMJzrv^`3n!%8a=0q6NB!< zLg7cSVV)oNR^)tG2`yojA2%ZdvjJg#CDH|U!G1=nJ;(zw3`QP=lY}2ep7P`798ee) zgnrb026+)UOQW|DxeV6{*Y`Jovo`u2k(+RraGudF{ft1~2fht+-$6c)f&O1!z+1u@ zO@)zFpWV|xaexR>gug;Y$1obnY{!U4IPr}5e(1l%NZ^N_OpJt(0n=eSBcmS~gUsZI zo=yx#6(cus(jfErk+I0Uz^Lre?-lkV(!`EcroO+z_$kUj$+h=CWPxWnnE+Kt0J32E3S!Ww1zg6aTl^JP}iP1$N?~!bfzF< zpm!BxD$FLFIydI{@iH4X=K7((6=NP8AkIeQL5L9XUPV$L2K7acEXF;c9=zJNPl5W< zb)R(~wC6Gr3^=9Zg3rFgAsIx#D`O%O25b~2BH~H~(h8PZI=@jGQ$%r4o zb#h2Scok$yNX0d_Q>lUap|=+m3?ak^6$;cZy}$6+)uQqd9)_e2R1d-*Aba`=%!TX) z)5tq3a=M>D>R!!&nS|?nXZZ=l7ZkQsTM4IL_|*j;-gL<82l zUxtb~z)v84WDbR4gy%pG_v1N&9N|Zyn@JlmM^WCRNPJi0Ie{Dt_>t!%auWPPI_PXt z|9mMco^wdbq|x&tlX97q$8!-$nKariCgn0IkLNNH-_U3~nRESkt|I68;V)~&obShT z4Y|ONDu`SNi%91>adxHZN0mkH^yB#xxeE@E&R58Temswm_?dZ_aN3-y?Th_9kCEDTX9)iWc^0r) zpti|*&_4Ao65lrQY1IVz5?&KW+u;r1->Mn%9egBQm+KQagtuUhh^uM5nURJc4{2G- z4}TTJ=iz=lq^;+h8r2SIgBv|xAw58YQtgpJemw7yar}6*AmjS+d_czY!yex$a=1j6?sC&DDcX;0QKFqQB_NL^;i=go`Mqt%fyR>v~=b=;A$!Tn}4#_X={WAMZY-erG%35y%~|llXg(y8!7e zjMRD`A@*%w8TG#(upnZ6?Uhm-p*G-WhA&PfjBBQ|}9KCGuqj=9Y{CJxq6~re# zY1s+_(rW$UT5>2K7N60Q@beKazS4IZ2#S$Ww5Z@FBbx5h zPCbWWLru_9WEbd4_)MfuYb@93A37dpas4}T9{kGne&hl_UThYs^;=H(A>;}_-mS=$ zu!C^y8;UJMuW@}F`KKT24)VDlPU!`;CCnhsJ*4S}FVXoE18@=k0EzuH{B^&C;VT-8 z`Ut~rVfe2_orK{NVd=Q0Zo)G7(QQ5~qaW695|$NcAG!|+%jrk=0b$ryqx*s|?5ffI zL0A<({GyM9RfV4jj}$)B@naW4qN7GpPif=%u?r&;KtkF)`KC?jhre2owCJg^izCrR zV^eQwEBLWXBJl%_T?*L}T5(-kBt7NR*!X0IBYx~MBAM<1<+jU;Wcvot)z-2;P}g=f zk?f?GeE`?BMRME}$w?Y^FOkKhyO=t+FC*vr;V&d)i2(lKqAW|s`3YKv#5b0#BK#n7 zEv)03dR+1j9Io$+EW@@M7xla%H=u*-1(LF?pezAY`cvxsDRvB?Ja6~<383CEHGjHD zct)0wp^$@Xh$d}K05)`}11E~>;w)?0!*^U`H{ZYN{Qp1k3*q}&15nQf`KgKYx!BHZ z4r>7YIqCO}(|VlrjcpIGiwOf@5oO@oH5yL&^$5WC11Oh!5_2ocq}PU?W-tb5JDxkV zSIQh%2gomo_k;SvdA0?DfO?O!0UipUK0!Gc4ol$~dktw}7U1jgyTM731Px#qTo6f! z4HHt235URMK)Xql0I+=`>N!z=mBkO~J$b(&+M_(0mJ$HQ*MuPjg&c%J4xV*_agucALB z-4OH$C4MMjVN^$0Eqpr%@I38)z<1J-S32q<{ntR6>F?s_jiDc4?+l+rGV)Hw*6=gX zW;0QiOkY7CAg#=~0h?srBa($OX8A)TYjxT}YCwnVNnt(hAT!|8IVoq(P#~Y2GvSO# zt_(0nBzF=xE0V_x1>qoIr@ZxGvq-)?KpOcA0cqzyFH!(q3Xo30#DE7kVX9 zxD+f9DN+EIixf={*rVvL5G7J95&R_l> z9diNib>zAedUU!h(wVY$o(w10=1U9MxyyQZDAJYtu6^O6NH=7+Q-B@2SB9e^JyOGW za7&~ow&{6A_;XmGetHduKSaLwKtH%A(i=bOjh*`xfEglv@v**(MEYd`e7S!SAa4KJ zB0pfSAF$~U^Ge2 z;gogwV4%DsGDAzCU5wZV*F;8|KsqDa0qKu?!&YK-7zEhoxlQQf*dKlm%qp6S45h6dQfRfMxCICABd`DzVVjye`J~DiIv$&iuLnN@I*#8B*nNT?xqE5HVmM+3H-jLj$W-V}75Lb_8( zcS;XHhp7f&>#5jeY6lny=rWbGrrs2p<^rBiL&s?&fp$9WoXB+Yn4Sh|!7s31WJYQr zjTw{RxX4WEVrF`%4EWJZ;><*kSs9=qECuwNg?_WqV|F6o*=))-y8-k9@|%4gqD1D@ zhp}))WG=oiHwk2dB0wH<@xQrKU>n>QnMa!Q!T=l1j|=EE|0I0!^J^B7Uz-4B{q?EH z0)d2(9ZEtq_*rBjdMzvpU&BwZ2xza1-0&rI0ovi>ioo;55zKK&d&v->JuS@!e)l4fy$*5`b;jW(DlK?pqitvL4&6Un{a91UkS+wu=h_>2Ase=(`EqZ0-u=|65+5 zJio_*A4UG~05)vM~`)UI9zP}b65IKO(2kOEGjxwmrgPlYU;e&_J z{}8$z+9PtfK1_sgks~RfDQpor8Vr=_=nIi!*zp+td%PW70BmpqJx{FRc%%RjeiGZA zr2MC_->GIW3O0(I?gq;M{mx_o>ix_ik+Z}*+Yfl>9AW29ikz*1Zq75wPRuOe67KzXi`*0r91e%Gn98`%8@>4tv==o5ZaLFj)Up2q?EC;-9;O9! zcu0N^X-5wokw?iO7vM*a$m?-RXbinzEYRMc1VLvw%$%J%ewH1|LPMAb==zNEJWmM3 zd%l{DO$^1aKeI<^m~lYMJ@7#c>l;`K@5SIRj}1FQ3|B9BCq_VbI4FiY1=N9O zVtDwa5zj8TEe3mNhL>wE=>(D=XB9?Z8#p9J&>#pGBTg|Ooj7~Nh&x-1c*$WT+!P~z zDyRlcVF8eLf-q;3enefbS#mG_s$TQ1BF|uO!tbO2#7}-+7P%*N{hq7=^ zj2x6D$5z00IbA><=z>s@8?Yj^To(l0e%xBe|n&t z1**d~F$$7)!ES&~h2{cr3Y`?Aa9to?5$dWaaf<#aMzJPh6i)+#0Na*m2RFnh*#*$E z)OYYojMC&=8oQPL#L?zDF}`ffv1WY0N6L~`*(fo-ngNa& zi+|L`W_8i8?s1?j^+KT>j1{B41+8JT7!B~RhA9BO8YO}s#b|6of4IYOZfYnD^ZfBbSPA$; zC+esZcJ1_3jLtcL`ssXHj4tTk1>L(`5u+lB95mo^Cjz|F5 ze+0fY0^b@zU5>z)M!XhdBxM*$-Xn(rW%wyRgF8<5XD;>@Go=M#VapJM!qZGQb( zj0Iju3Do&Q3nF194Z56Ju2t*e=Fu>V8cnpuX1T0Q!=3rNmf&0HVa$K->-ZBJ+D= zV^Sz1#->Do-8NCy&AFj241{HHTa4fEyWc3sZ{+nGI{mg&jNcXT?(c(udj9>g7_0$| zKZ?QvAg?X?pdC=pTO!2R8V3pi^|6&SwiSe1Vr;JlZGk+u9~WZ>KFIpO*fC0soz%t7 zMSyO*=+k!LFT3&2-IK)Fi_GM?-X+W=df!d9nh!F)I(#%bE|>0jWU7-znOE-)Uj-C6QG+X<$^ z4xn9}YYgag4m+O5&gZG;^WkD#Xam^rA~v~5`7TZnua=)Yn1mI`CgkV#`OX~xvmca;#_|s z#*MRLg!hJ7fNnR#U^L)^w?Y6L-a0SF?FKLfDD&-mVnk#F(zsI^UW#!S``kspdtX5# z=n15MzcqXi7bz7_X48-iz@jH+(O~+dME5$m<>P-%;*&_`~~zKsxW& ziSZ#RWCr~51GfG!9PpiwmEp1&{NB64Z?hWwro0hV9yW^+-ChhQIgAk{HdKTO@Jy6Z z4OWQaSF4n204qhA@!>~!EQ)Uq6yFLcyC7T=iPh6-A z>)@p*Z+_?w>*2L1zMWBl+z0YsXb5~RDkwM90`d%60w;m+IC-HLkYAkhqBxUKaY-v~ z4zifS-TR7%R8@@G-0&?gmkOI;i;i%P?Xs?fEf!muCbbBZ%Jm6mkVwt)qr(ov3d*e-nyQ5krifih&cD=H(;GL?s4 z0o!FJ&&*dvWeJ6ruoEtd%Gz60Hp-Z7v?$IKRCe^r!GAj_M`0k39Hf=A8C(~Ys}Ue` zbD#Tys65y+&t6e^JHUNW`3eE$$e#k%h$>JLc8DtIg>T`2s6u66BOHP&q6%jM{Gl*q zER4;IG>1#zh+-X~iuQxqfWAdviYnF%#=>Gz#dEJ;mLPj91N@L)TsLI5xOkGy~1&)aNx|^sfZ^-W(>f)RAqN>(`>!PYr57kbJ zsy;;2w{9TqZ%>P=kqs7zs>$Sy9c&r}=q! zCaMLtXhED7wSf9-iB2u4gH{EA`_{AJAiNdThO)Ft2|Q~<8*77qw3z~wq0K8%ZL`2v zfFHH}!B6{kqS}+scRk^qs1C&GKsh?hgJ@A5`-v8u*jc*RvYy3@76R7VAwP2~JiSdAXok+eDuZfxz3d4Z1{n7|_i<(S5O|A(8 zV40{X*ltQiz)#rsS5pPPg>|B)S&$1l1J9<{1>T#!7>>XTQ8SVNHki>4Xa_T^0JfP$ z-m@sntTTM(mIo;N>~o^#6amUMhq{>aM$}yFJ2y(yJo21J8RnDL{6nICtqs`iSL*QB za3Jo2IFJVV0s1aLj|KSFg2xakY9YET%m9M`Ut5UJFT!SvXlsjh0`;^wHBe8BvD0Go zTa1mDP&Z5PizU?Yl8LYnUW;0q8PIDfHe9+1{uISNy;@co`U3V_c1hH7>U25fTF(2- z_0{sj@KMx?tWX1Ze+BQapd2gRkQ*8RdalG)E2*nhgs&Uc63C+Ye3g04wr~~xh8Cd`=YK?gIl7mmI8dn$9_@Q z3Ie)bN0;jr06nkMKCefLx8>8S?*aD;%jvnFU62oPQW|2Ho#3$x3SS}%6%I<-ll$T&xPNB_ip2t5t)Ft7||9c z!47yN>W&H2-<|64BcQ{bbMR2qU2J@}EOZ8JcNf3AdkEf$x`!{^s{*~@hN%1V;RJjV z^=D?N0Rv$b;8PE5$P4K3fcko{94-of#st*QL+bhAZc&erkA8xUa7)zVASeRZ@9_vA z{P8jPAnHj*s0h7a0pO2MqC`E-3U#0(3<3Q5DSAJ}PS3E@v!Z|=&)UOO*az3(wW#O8 zP!ehbHhw-6c=tK)K7TLjMFzkRUSRhZguSG_zQpb?vHMHx`f@Kk7xgL)6aZ}WsxK^p zGvJ7NogL8cHFkYXnO;*@uYZF(qTa*<>gr7?AkG`&yqN_jAyU*^p1rLJ*zoO2xGd_O z2e1)mGwR)RQSajd_4R%|gp2xs4L=lus?Z;n0e<$;gxt^oMgl(l@wTW>=)ixwN_`pw ztAP5841m1Q2=Gb%J2NVBJDe94MIG|r%urF-C8{-Gho~KZe?^l=GEa5RdHwo6M8%Itpbt<6?{q*{?;mg&F2e)(AZDNkQa~0c0@a}%Oaanny=n4IuNhPonm}iu>_O-n zG#7q@+t0Nu=O2qQ6A6x@9w_u z9lafJ0v1lVI|app+=-|t_KsK)6bm*)6c9yJ?7dekSYwY}WAD9d)M)J87&S3!VpO>0 z|Ll8clJD>T(FcyZdv|ANXJ%(-X5SaENz6S2r~%+^Q0|?86d(tf0xSkL0{emU0OrC& z3+RDS0NV6e0bs6>TVo#Jg(m|*wMsGGBvt~n zmM{Ue0rXb_vQ%OaFb+U_C3XPdTZu;!^K%8N1F=9a0Q2m38h||dfp&jypc+sgNCeQ1 z|4QI8z$F#{S_1HX0B8und<49dSV_ot$%X*rvg8&3ZIyBXY62<1V&E(QT1$h@(g^^b z7+HEPa2R+kG1Qy0GMJAt0|AV!4EjTEkp-f^K=c=g{sPfoAo??u0zkiE1h5gn9qSBt zfcFwB>jYQ<@SyBG0H2k``$3q?AY2oa3xLL;dlC!w1TfBE+*K}k8E^prjYi0=F%E#7 z8_~WIZ5YwM5$%}Jz6tG{(7tIl0Qya!-wgUu!^q4T0QACq9(V$Lkytq|AOz?Dj03g< z=)b%NP!6aAbObQ=@{<6Jzx-a{D)2~RA&r4;z$=M`1_6+jP_$pc9RQsbRsp{Q;8#V^ zUJ-g+u?Y|lK$j~H1ttTFfDHiTyP{2EVLm`b0Ca~z55ls5=>Yf~c2{DR9DoP_v{gbI zmGXf@0Q9SJd7vFI71#ry%_@FCa{%*I1>>l40C+61s^D|g+CVn|Qv~EU0yJ5`8%rBt z6tEe%FEOhtP#M7cR!Vfz+ks=ikHBN#oy2Mq zz!NY4Re-j@5MU;-4mbkbl2|Q_xmH~Oa#w320D5bI@3pP~zW_xNtE~qr0gV8(Q5)CS z#QQ%w;sLjeak&IzB*k0KBLJUerO`b@l-Gyv{EG+ODey&~{zS1>#Dq z?sNe2SQqk8_b1>tiNz>D4FEig83D`(HUp=CmlCVz3}BAxMFCxa(E#SJ-ge*|@EE|n z)CWK6gVy?>v;Jb>5@3^9gNgv=vB6LPwxhvy;G@JE`T;e8Bwz?I6F3R{EwM)KfEmD? zHR=zH2bKbuw?@B8tT8@s91XzEHQoR~1{%MWSQ9N!1^^vRS^=P?$w(j%*b1Bh9s=m2 zDcWcn0btxsX9MWF={t!vD+yEsngauXIlx8$_N3W!i8Y6QH4g+VKs*56HwO*PZvby3 z))(T^9)g8zI zKtn6g&{S4B)>;Be0MMb<;C*Y@p4RyQu5XRc?EChd$b&kM`)JJ^DZmGHc%y=ni16+ph;M1Gv5eKJQQm=mksz zKtqRvzzyJy#5!UgJK}oOC$NsW06y<{9{59I@xB1~ggONl57~_eA5gEr;@1L)ftwQR z!~pQAQ)gfbum^Z1u>`c6P!s42EC3*T31~C16aZQiAy0T(5P`e)Xq zEC9N@VBB3s0V{x`z$1wzNkBM&F(u^#;73;npf)fF*a%<@U0+G8n-dTMGzC(CDZoYm za@^e;Xby}6z?1HON~}i(AQ`}WJyruJfoBp+mVscPK9CGd1iN^L7x>=`{O#2f7zS(sew0{mwAUNF?G3*7#x=b+0Vjc9B-Y0XumG6PK4XEc z0LIt{{qzN2`nCcF0?@m@2LQ-)3dWxj3bX{Wfh7RuDCMQZ`gsAMuU`@{1VCT?u1G8u zG^B!tRM3zL8dC9oDrit~55K{W{w~ERiQmp42p9*<16Bjzdm6@;2091$07d|IWdL|N05UaT3ILfJ0NXR*76ASX_*-HF zg8{TXus(pc2POk(d*C<#Z4X>6v2^ew9ehfMjZKGb%5Vg5O$PXoF#v!JX5<0jZwA`W zfJ|hd?M!#T3`7GR0DL!dBCs6T16%<>M`n@42I&FNFen{Z24D>z^i*P5I-m{!`U1*m{w2MR~bJ6d#uG%1)B0)L>FI< zU(X;FZ7*rZ`gOWc+Oa{ycyffj`*J-dfzmehViIXbG%=Ljr9WavD1#!2upnKyB7Tq& zJyv!&O@ex?Xn#uS#j~h!vG{=tO5(ex(Pw~EM)Zj<2U){agtKrRpbb)iMsz{6$Ico1 zXWS|Mcee*+3TEw{xohVBnLn0(+x=$g57YPi?CidaEatt);!ULF7P5kO71+X`ZQ{LX zLxSw76jfASPS)f}A?V6tGMPqt*Cgv|5cus|~W6OjbpMKP~jJ zQ_Q7$m)xD-94WsvWZ`m!KX=J%mFnymy|dO^59im%&H3hS`!vK~iH~oWO(rz#l~{4g z<4t$HZ{7?1;|O`fXwSGh-P;>yz29=v`^;JYf|F!u4y8RXg*%FVQR*vaaSIlIshnhy zYJe~h0}9OO9@H^V1QIQvRih;qi~gTa^(t{+KU2&^PhBT0anQIO96x5MMseQfqEzbD z%Ed`rrK+`+Bg)whP8y%@pg13zG-{>8ex+LF8cm&@v{kEETDjQXPGxD6mDBRZQ7tB~ zmFe2C^=541Bda%-n?$#aYC>ttsKQH=)=_!==z6m^%5>dWYHdbo<2tcXjVNsr{jr^# zjFl6|Y=4yxC}*Tnl1U1eBpoORk84vwHF%1@!>LwpFpJR{eXV$~GdQl(=zaB82%0I# zq$%%orF*$*T8E6o1Lq#pINi=T*w*u{Zp(Up&ARKz;or&e4mmeVq_{h`PnVfCByPB) zCbCNHL^68MjOb3e-7NWzy_RWxg??3{{Rr|J*)OL!D`J(vyY{Sjh`)hfn77o-6XQiTU)CB$O-^E#wy3 zSraSNl$ix@yv$Z#UoS1{d8=0@9Xgew%8}^78(Jfo&hK-}GU7-Z9au(|tjw$P7hk)F zzp{Pc`5-EpMzW*O7&pj@(W*d4jCw_I$SVX%6mOv|HS41y%z8bm~8PmUIc@-!I&Q1u0G61+1!xZ~Grvh4FXQi}%JaFcv-)+pv6tJ>MJG}~*U@JX z3v^*M&|KTSa@0r)Q1T#!6ul>@1dp;3LgMS=s|nJWOqR3tl4xSRdWmu;5<)w~#B`=@ zCnTcJ0Yzh3AJr~N`XCbC;sNu2I6_kq)}uXcj@(o^hY5o9P*jb^L_yr3#f(b2YGxB- z8XriQPG=#{4_#)&v3wO0`1sHjyb7txpAMXM-dfc|nRUS$;p#1adeF2fjAsa`h6h62 zZ`PE*<2U#P*?dOp$WQPsDGe`ZT}e}t+yP^FfqBeRcEb3=?CKP&(MnhG7f1QB3bduAyZ%RQFcA?N>pvv+-u0A zaZorjc&x7~bO>fbu>^wy z&@KFMqr#9F?4|-%#7x#s>^;@lDQ`d;o7}l6-S(Ku5B6LgTxoO4xU>BjeQ~gLZ%Q*eC#N9xNQHvP7R->7 zDwV=!L!7L{K!ji}SW$k3mA|ms4tvvIh}otmReSi;;9vPE5_O7gD;!Lz26Zt~J={G# z2aS}5Q0NR=1G9uz^%5fpqh^DcQZYWWNxS$YD`~R**foCWflD4Pv){}Zc5WacK60lP z$)jCeIwz%cqF3pocl=a!{`c)!FNQNR;6!$OPs$dK${0r}La&8gw!*hV?}mU!`n!(=+@!GxK=jb-v8;6I){=`$aA)AoA%~(4%lroq*Z)!P(S`__8{~ z8d=P+#aL`-v98${GSIF2*K0Y}?M=J3T4(u3ts22$ zS}<%{_WIT?Zri4J9k;GJg2aE+uH78l=(e zw%kZ<)~F*|qNAH_zgJ@J5PF9o65+F)m~{rIZm zQ1kzIX>}dr4+OS%cIw@zy9a;nN}SIhy5Z`wdsLz~-$XmvUAKny63F2(JM)5)`gOwt z&0EvM4`uo4=8cO|+KuIB>LpUzu3mH(ioAnVf=6j~A=+PE!f6`Cq^{hUQgueLeCvI^ zgad+^lqnT|D!x`cme3T8cf6!vgm-nmc%R@Ci&dvero3@eSniDM5e}NguV*wFoiIV` z+%7lYlPSqRFI~-VzZ|c1Y?DPwtlVC5^qX`1w`D%1$CL78@*QF%ZCo{pohI38I`_1s z`Hd`N%3W{tQKrm7W+Q(IX}Fuxu$s305qNYKsro2<<;T&C&E_xo+ymEVoMyD)vi5Y| zm(`ES8#3V>Q}`PG(+0jHb2I6*g0VjJ$pdGqJV6?#XkoEOsuin~SR92;;y3Hhp{-mNfV!b&i``i-bSU44CfbckO3o8zC3>-S1U;&A`jgX$~Jk z`XzMgDgQ)iay&kQD0L|MRVfMoF%Xn$U7mES_c1o!2=o}2ia6|-&* zbI{gZm$~Zd6XNK~@1+e|aLf=WE2-Tktn?=@@_rq`*vNNFhmkZ=vdth_=I`E-DWhcN z(XAi*j2pp}$)g|@Vw`s|P8W<*jIuO5JXO7Q7^9a?m}v}d)!f%}+#Q^>6?ixPvt>ih z`My=)UM6T1%8n^7;iYP;5l-?g#Dp|)u;xT1}1 zv$y~Sl~Pwc7CQvC6n=y88{@EU%6g*^X9~w#4>Ki{cy&vD{m}d;V;r4YpCaDtpAqWC zUpS}s+xL^Z(}+>?`&Qu}&9uVa9{rGdd%t8B8BdI}nf&=B$r&VT_*Q=O`-4<&R&d`= zrZU?;I`|AKp<<3891NpCb_n$WC-6u8|=WX^0(P?*ONQ8l)@MG z>)B;ok5h3*Ockh0rYRwX=@`j7OppB=nkRTA99Eq=J312NObt3ZWhX5|CfN9$#xrc! z&YkE|4;?Do3ZBZPzQmH{bW*`>xw$QzkN(<>N+_n-U?7500?y6j&v?HLg3ti6U;_z; zGZlehhOP^@u+RIA2%)UR`$vN>N(XE(!FW1qj z>v{f;5C^BstUb5foHDYPUJmqTWB*>UnhYZT(-<57dD%8TjsG!;>63Qs#YAu8*R~&# zwS@g<*AT@CWIIVn#R+1Ss*+YC1({(3pdCgsualsezaeg(9{fPz>putQm+qFt-%w&J zf`;%f*KZa{f6|<*!*TyND#i0cr6NY+i$zH?>b1fUOVD+=k;Tf##A5$-G!}OF{Mn+& zDtGvw?v9q+J+H>jxi`vDaq_HpNt>DZZ9uL`r?+pS;QJAYYoL-Oc^TM z5ny2S#b%{kbQ${#NFNTW2VP5(MogXZv0qYorAHaxxWMDm-A(sv0*HkBw0R9(x3 zs96n)2amnR?_T5WLgi8Np@Mqyp%3_GTkPN);F~x!N{|W{9uHIq3aGAlN`uv9`L2(P zpQd_#M~vTTHQt+tFVnAvfYy1(U&?Is>-p?hVeRTwR%zr}6WB2{I2&CrM1xvVwF*760z5b8{$>#|PM-hnRTJ(}V z#ccrtrBF#Sn5@uac<;gCh=AagaNUcyZ^FCMB1mF2YvAK)d})>|%~?F-0Q|jx-^aOW zm{O~1Ork4)t|jhg_FnaDqfi~;UO5Rt-SZpxX&h>mkIa$j597BVqIC_WD@736pe|W* zjLO&7+P>6jR7H12PCG#41Vd#D3TY%(^g<2*)gB@uhcm`-GXP#F+ghu}5P={pLuIv4qZNY5I#(X#b7dvVt`c)2U*3Z@bN8{Bz*6RjI-F%8t-D4NhvSr5`g^S?@ z|AEKzbifD#g!7@ZAf}?XDoovMnynB6i&Yg}vq|yBU&X$?CbBefzOcESk+AKh`1$7p zFUCykG9xX&q{ra7%l11mQmR$6%=osUgHjjhw6t^qiDdH7zNFyw&xJDW+UE@Xb!%gLgb)J%!W&YP@)E`up&gihD6+~Jt4@cgdDX8i zy*jSHwXuGjzN&G2sgnT+n>UCT!E@1I!PFnlQ|kG`nbJA(V4{oZK;xq8br8)X1%T0J zgVJKR44P;a^U0%tShXxRmp;k1Y`i$TY zhD4l+P;s?!O)pF??zTX*f|q)gp+;(#1AY>rGjHrpVx(+B))t>{i;U|%*|Z>vPN8v|3Y$+A(o1}4&m zp}C`XF_CKT|LyHqi81>Y&GE)e4pNwF=75f9{Gc2)DoE@>AXI@Od+}+KeRF9(VTaKBh$n9F? z=E*JT%z{On^J6ld{w0sNkeasET?bJ4?{i%twH6tj zD5@i=8b^!lG#Y=jQK+AOP{7o@|_Kpg#hEeNU3LY?F+TTST1xJ7Qb(y{1Qb_G|$H&tCX zENDWgkW(oOb<%$et(g^H_-%Bs$H)YJ$Pr$^-aSt!e@UmsbaQr}RBph8eM6ZaaW?Iq{XA5ce4&tC%JT9WLy-c)aM^>*q(%2DAC;aqjckJ z8g+v>p~Wb~Ra-&6AfiTlGsQlgaPHuJWbepd;gv=FhseyS=h*fWNy&r!^T3IW-rGeF z+UgogB{R7%Eh;#Twh|%kVQ5Qe9`q2`lk=n+scid;zu!knBVq7U!D*owQYO}l-|cNZYwxV*Vq!|8nzB}1N3SOI;w!ng*T^e zju^TEwJuLdEuMXsKN`L)I<|%b*ZzsVdpDrs1nmNJe9+mrM;-0Rg=pl^FpJ?L0 zj$J0<>90rVO!{gc#%tya>7Saqs>cB}#Ud$eC{`9Pqh5pPD+1W= zRHG-mm$hi&RT5@>gl=Eyz$g-5X}uw^?4bsA9LvbsEWR)zd+4T1A;Ia+R~&A>APxGg zt^4-*v994uy1$8B6@h-r@b~1lV)qN-(OuX?+&1y|8k|WjTE*wl0h%Z*bCMPvTafj` zx(P!rl5l#go}hy&T||FJ8>{^dsgr`aeqYX2I$3G_eAFis*9kqx`?xSgcwsc}O37Dm zOeFB~M`8?o^eph!nzDHsW!dVqaO_ozzCbwl+2bt)Of|yy(ObZA1cdF@qBsMqHE3y| zr$;+FDzu;=v{_|~o6oZH3j+L!$Jry-W&To`-ms^80I5)()|uPCjr{Hps%zb5$(#FE zf0yM)hshR3QxcxN0heq=&y`I19cC7ewoqcT)@+5VZG~7{Ftb*@R^&+ZTB0U>L5mv4 zgkyGb_kpux7v(ID^!A^fIj{fr?fWKe9JZmhcZu-><`;f+ufMQw#n`KBjAAYO!pNEK%<TFBq7XFI(ZpqwA&tt^T_jb|r#c!B#7D;p-k;EO$nTMHwo-B=^z|=#b>>F!59V ziy}!TesWsh{^Q)d^SeDe=;(B!tCI`ST&s5n&u4wfx+nIY>h4Rr>SYJ=Nes` zTa$)b{X(mEPOFJU@<;hP+ppY0j0Mbu)1@X7;k_B{RSVvr({vq2HREWD$cQ%N7Hu9` zy)|uC-P%@(tJXqpRxJWK>_*mVEs(;tSeqiB4c2uoda1mEocg0kpr*KoW zK)H!*HVmUt2{gU{9HbuNdnXE&t1+RZ=~`XQf}*VQfi$nZ{$C%UP%0IrZM>x zUvumb-_duhET18XVAcV;lQqS-0wmlnjhJEHO%WCgww+c`ubLy_QA6R4RiTs+3G6ug zvG{>~htYlOQ(R=$GCN?icI&vIvz#JiWGJ>bNGuuKwwI%}B0b!=O?GnT2x<*$hJypH zX(K6JFoLg%s!(}s^kf!Y%~S!on3~cEc829kCV43C#if;pk`CBD6KNzF%+4{R2p@`y z6XZ>DPlnm@O0x=NFpbE1acA=&Wg^@x`VaYi7? ztXCD?Y|i-qaeIbupGSF1iTR&NA=4t}jVIEKMGA|lUtdF95jUKtp~P7m5;JE|TpwrW z>haU*wf`^IkF4O2*2?l~QvRR$`IT>FaYUJvQKOT&N^+^8C8H5B2@Y)+U0Pw9%3LF*}9(!XNkrjb>eh=i!SL}ZPk zpiwoDjOe*K87R6z_w)>jHu2+;pCb7I6KP=iyHnv_BWujIyyNpo>O0cmOCjzzAhm`& z_Lp)*HEkl*4Sok~V^-iccU@W5((n(y^ z&{zc>??)KtoqhiVI~_zel1BXaXN|;hJB^~7@XyD<)lq}HVwDtrp@=G!75f76XK#&m z-1v?YiT}Y*4k^PsH}8P$0QM`kIc-)jIh7U`oNmyWR^|zqOpB4>tBYkn zK`i^bL?W+!J^YO&zvw!zL>j?0L(s|!w)wz13XL$Etq;6wM<3ngFu>ELdr+uj9oG)E zGe;>Kl{U4sYzDe|hFP5kQ55cLkWMSg99+&O9Vt!H{qRYda_ciieEJaG%!VOP=_(eu z|1DvHgsK4pyH7zI%vyK8(lzP>hr@1>5_w*KN?#e0o!u*);&%kgk zj9zzzHx3T2)r7G0dE1ZDa5kAOfh`gDht)XaezoI84p`cOYjVJRd>1#ra8R$UOPArA zy7bdO*Er%D$FJ8+$2B`3lcN1y>NU%dSH@;myHr|1mwfFf5Z45%*I>!L$%nBfcmzlZ zRgz&};d_W}3L;->Pz95L|KB`0gd*r9hqmqOkMwk`)}T=j9r1VNe_z=Dv$OO1+3oct zzBn|Y1}Mhm>}V31l2)fJ9KH_p$bFe!+`e+b&{h+O6>eXf`r-#jKxA2)3je@eh^-p( zFc8)E5V!e@9{P4Z}u$2cCZq88N!1iXvcziB%}$lPCJ!tZ}`$Td@w=H zA8t8qL@M7&kMmRB8JwqH%X#%=yw^!}$x_$>yiizw>lU?xt)*aR7OLX8P3ugg?e#F1$Gz zl9Dt~!INs(f0rV@KW#bh z%mO?4YaPmGM^HyzaA|FN^Y}rH(_9@w$N76R7TB(|;!rC(u9v6W;?75nd~Ru2>jkxq zVcq7ZN9?>pY2;HYZQh`A*SwlxRV%id-q>6_j(r-D>p6{UO)QM*nr)ieW1O>7Lzeb^JCZJZC~sx@0-3a# zo4k4}t!XF)2eED~uN8Y`rSCwImcF?vHJ8!~WshZDk3CFS+xijFbgkxPncyItb(N|i zoZU(j3Tp)Kp9pI0aUtZ(eD!uQ1DhdY#H7YY?W$;HyE@eO(Uj%;o{qlI$HjHR?a8B4 zHSMq0UfFta>ce?QYx1W7$+ZT~cXR2`uIKDBdc}7MKe?kC|Antr*ocQ?=Dis~<)+g{ z3>y_+FXTbQ$bqA6;pIc<%F+ENGxpt*T=3W`4M$|>9$vYr5i2aOsNaCPs|K9?^HMHd z=vR)tw5_0>8lWUDp`U0Yw>jzTifpWjQ(lL*y|*kF;=qWf>_n0S z%Z^-(l3y)fUbD(W{?odQoDG zb=m}-vd850>K4?XMfnemi#@6)|GnsXp-1-0yghj8qxaNvBNucI|10p%5~O5_MTJ#p zlg2~hTbKurm?0l8s6A*JDojsA#;+rexkzxl*)wrsVdWm_R31XMAm02I1RyM?yoD{% zsWE`!>Npq@vG;`mh6Dgg_K?y;cJsUaZRb<@o!x1r)5;NZc^Xlk7z?9mgu!-RKD(vh zg{TXV{kOb)`O>yyuWEsD7b$omYM2*MA6TJ-#2;_iYa$Ngl?W%P1$iiO5=lPt$FK(c z`9TuUxG{+*LlHqP#n+OVJYBBA`;t7{OB?Q5B_bm1chvw};9$n9&b@N>w=du8sn zRdf6UCYPBs5Zlr5wYJsfrQXru#%(4#78fI_Lq~z-@K5X)7hn3@+%j`U@#h04m61s zReuih2@56ZL}_xB^$)cTszt-f+pgC~Ogg9K&;y-1FFIecvZKZ!+mpykh}TLIO1w!! zszce!Yn~H;hmro_Mo(6;Lw;<12+63Y`6iN`$(bwR&~&7dE-CHCv#boS*^}9 zXhr(QB4S=*jWNNhih!q1ah`s*Y1*XDlh@a&|I_f4otCvfPe0ei z1Lf{EX(h`qc0=Z?8;SHdrXjBOXlou5YfaZF9J0ZQ7#Y zLYYqclGn5QK*}~P@~QXEfvs4AB+#n5F~N~_Fk1*6vI@vxAp{*Rwl-DuTGc!=$1^3K z?W@@@%xY@f+3kY7@P~_3|G^RdEIdW#?(frln$P*hoIR1*$8#yknp z#q{YIo-iKLA|o$lQENstE}>!)E34$Y1b{pR~4N4>4v z-Y+8HSlM9yR1kN}5Gb?M9^+S`Y;VD@xs2t$T``4>Ai>Ltl5&%Jy>}+c${R$G_~_Q< zej~@I#d`!*u`iVhDE$xmcj6rhGk6LAD4bRirSrn0d(kq*gE%>kxjFRa!xAM)wZ}{Q zq@0Uv;uY@EG}WUtFIsRT#7SN0Jyn|hpZWR05bB73zOerRO! zKu9}yub70iOXYEYLXCDcN^KmZ9n1Yy^`xqL`awOt#YR#nr;nO;>Qk#Y#4guqazzPMn2{^Iw`c#xj!l0&5s^wa)O`Q zM(hQLbxBoGZ;1RM=y3%-E+TtmGzF{Pt{R6@tcyC)}qCfb5aKNS(;{{c0i+fmDuJOq#6`={o>F65%-0E_%TRR*M# zyMGrRIF+~g{7>Bh$=vg=!h=TdiI?q%{}vt;74gY(Wo$F`!nQH1(S+J&^#BgSl9Dzk z2-2lRj6oQCA!~YHlw(^hD6pLoP>ydXMZFe&oOkoJmyUng?N=gvY;9i+)y+tm;l&iD zO*DF?&edu8O>om5aTq{ps+>^W zSV#;OQ>!ox!sMAPRx9c>VGCgT_6#e3PvUDx~uK1|t5JYt&p zdsX0r3JDu!o9^S{KH8gZB@w4rk+u!{XEQnGOAIQ|R?J-W<4As<=Mo1k3a65z+9yG2 ztDuDAM;HsSe-K$rRV|I8$W{o6NEG3xFd9BzgX0htEuA!CzPn4m%;b6Q#OyeS7cP0v zKe{^3p3}O6qRk_0+1ML{_yd|0-+zIdTVkifcaJBdj-oK_!SP{RE#V8h zjX%~C8S{NZTcKQ_dwk~vMi62vY7YlVNUMlDAtMP>Wwv4pQ5qoj@NyN~wZ8t(w$+a_ zS2c|&LkL^)t?+f~v0HFkK6OLVKl^i3o&R&t5em-2Ga$@J0 zV0~B^rme8(7tJKBc?MzpkdwBWAjXKfeBJoCQ+pAOm{Pg&xf6aysvVl%uDFC{;ONz( z7q~k*1+(gwg{Cy(pH}KGANj>iqC{mexu+;-u^pd5*|bqD;yyK~(~M~!(&@JJ$4_By zg(LnP!!=1^h@8XRPQ$3xn%@a18&{oT;af9QLSdbUalm%CtQ$oP2YILy4MZWQF=O#b zQ}g(gdUY})N9cm}B`bvld3+|>s0OaLhYtb+GWI;J)U`!rLQJJ@I=cs$!*r-mevE#w zDM1lSfSQ;WPPWCOM;F5Q{HL1bvhU3;u`RvoH%ayA__e4d48bB%)FL1Leg{<-lEzKB zR9xPIfx*1d_o~a+I!PVaq84EE!lK{V8;#S~6<&{xiw>g-4;QPt8G|AbT4X#-S_D7I z>aHVvolgd5ZFehM($mwkN|h_t_IwXNNh5ET%XW>7DC1sF<3QtESF3x)Sa`X5sQeN; z)}P54TR*v!d&?`Pih+#Y@xd^Yik@kGz~r*_M5A!6g`pBL;bO5Cue>4O_#LEF9JZ_f z>=HAtj-BVCb=*P%w#w96ZF0QR4sB zP+TzG7Q2Tknljk@q3R2DYeHScq`@_SazHPjq{2ngd3~)l#_B=aiPC9@sw4Kl9-n(N zrfEB`L+;Z@d&qK~B`I4^xxLw|)=w|KT-IGJpdLsn5%~bZImsP;awe0Vm(1Ogrt)}`gr z=g)>#so}QKrC;9?9-(Ju@4xk`1PM?`+ZMfNl+Y-&P0M~We5oP(#}@grvN$lMCz-jf z;?&9f*n%`gLn^(l9MKIMm8EmbSF(1?q-^6dkkgTO)w-if*}k$HP%Uo%_xRkdndn(;ovOh%^HJ9f=rg*&)=4ac@Xx;0 zw~Hu_ksgZYcZxSm&a&&9!_?#Dw_5j%DLfjDv|0Gaze?f#;d^X@?*S!Lqf#PCpza&sof@%Bp%V;U6bg%wu|`2; zys=aF#7P@Hh|%#o{$%~sdjlODabnjg<-E6Ra`yqVT=`vB67%b%XM?nkpZV*YgJf{i zHdG!xm`uBiv*_KoXRrIcd0Kt6!>HP=1zfC!c$bM&p-&wgQZG$p2kfU6DDBlYG_>Kw%PAtS8dda$ zH9~+~5N-L_zE4Cag_XA!^A9mf;;#D%N+foC{oMU_8h0k3hQXtOcZ+tDC%YytF)op> zZrD-0L@&5udleSLsP;h#O1CVaRd1lLS-h!wnnI9lpB3x^;IN7vh?SL(sk?Tg=MD8- zMJSKGDa*~xHF+m6``!-u;fD_efmOOI)D`Wt5wR@|g)u-x!~)J@=;F+UNfHYy8WWPK zQ(A_mWa##L-#^>8EZ_O@HUAt?eD-3?@O=FmW!p>FNvp}PPqntA@A+%&(MvtCpTYP} zBhMVe&Y+{3*nDKki`9-q9|mhN*Ke%TQy*Sp-EE@ zdGWR%JPYp)oFvoRdr%cv$55(=S`|3cr#Bv#Aa%sakvK>*;)O75qGgqStgL2m$G*~H zX%RagFQXP&_?yFK1!!fZeeB?+0p*xB)l5EAxHa6vDP|AfgDIZj>{-OjZ$AvS9lCXbs z5^ic)I7%Q)u$eY`!#{zQrtj2aEX#e9WY)P6jm?cG;OaWPEOgpdLvT z`I&frD~Vqv78Xd#byzhC<#0DqsQG;h6gd}tJy3$uMI}h7XBP{c>iVZmjk>9UkXf0L zoTbF0cK?0p+0CtG<7x-mKGxYgOw=<@jfvWhGR)&OXv=Ajkul$i8lCZt3a-zXC~6xA z^p`^k{H(91R)h@ewJ2Rh+@6@NM)mXx>;JhdU%;2sQ{oH@nOa~V14v_AQ*n}o)u+1& z?}PI!C)l2ULgcu(J*{XDQ7|L^p#tvBoM8Uv&-Tj6!i7P^`>3d%Y;K?v z=x+KLC6p*c*-g*VSNlQQBi>5>0zpE=9$_tP^r`BRpa2GGI)=5_e#C~_ChcwIuG_`$ z?taSua3H}nebCMmM83s;3nV9PiJ@|-Ko+W7#|xGp;&=0*7_KkKq+$5&P3SuZa*%AN zAMosmqA$Fal8pW!FzT`-MAS<%5~0&XiOkdk$Bx^5$XwQS?NemZ}gTcZ3zfb1V? zYej05`Y>jDJDH~U#}=l^g6AU{%_si5P~6bGEP1;41Fy1zklZ3EKYgU^K%n_WKk^K@ z8MvixSVSlP?8v_@M8qmLD{os#yh{(7xyj2ZH6ebI2Px?^(*ga zBh|HT%_aPr-EGYGB6`v`rtgLCt;1YQ{H91KeS#$q?xeze!1iW*{+umL)9E27*OTnGjwCJtNfaFl)C+ANMbW1o!o=^eap zlJIy*6o%d)*fhhJLTwB4u)jZ2lFUe%?2*1mB6ZTIs4}iAz84hLh{7NIjp(RjuC^80 z!Ok20RtMX z6Bd3Z{Kumoeq|e%^0oXo?B>)n=7pPzi_Q0wS~z7+A6=c+f8t_!>ttDP`;ySU+d%f z$F{5n`Ql3dRUR$)PyhEEds^Sk*VTC1^epFBr5UjU*UW;rt81jT3dHw5zI6Mvn73Xkq-@gzwzp?O#by?JDgxjPs*7h zlT$4HpNaK>I97pDila=bV+(^Me0)1p2Un+asL~^dpMLZFoxkqCw+#3W(U3JSD)x{g zZM*;CzhU9_`(^aky9gB4j;OpI)i{2%8OC}EF$6CZfV-<*S@gcRB{%#ANx?SOsE1Xu zh{9$QH4Ga0j<`B0+JL`#EB?EM-y;q1aMtl-j$9_8OI@^S%FGB9CSKyaUbTyS7JuA~ zzt_f+N34HALEHDl{PTi2Sjs;0X7X~xOpMSkBqP3VU$Ke_2BY|#Dzah?mV^y3%gU_% z`|jqty7ubUd6GN7tDRdo>t%tv*Oh6WfjkYz?k4(?exz?%M?y>C_Dl<@cl8>>zf11k zi{efuWW<5KRJs4dvu&B@_=KBNt?!!=_ltG>!^=z)J2ja%V|#IO0xN)UK1F|O?oXvd z5TcP3Y-lYJ)y!BKMy6jl<*6H9v#UFQrnMbDc-ukKy;+*G7f;{`K2v_V;E?_ymkcsC zSUYfpOsm(Vd3&k6d{&>8^^&%};U`<(trYigdg;JAad-w9A_raN`(S}^_tacGW);1Q zps100PoFX7e0SHs`18L5E)JS=l|Q#(=RB;LOom(@`K5=l?1lqtR*+V zn_LR^v>L{tChlObEa8Hg8j;!8!j9Ti&Zx?a-DDAyJGC#VmNJB%Qct=TN#WHdu9Vru z@3K}098DoX0fXk}?H1ABf2E%2z|ys~sAex$+rbU@Yart0SmF$9iX)vhWL!Q?Xq$KJ zChElLqvJK|{5v02h)kfVT)nVz^|4v6R`f=ZR3Qil531Vjy|q{XG?F1mI9cMvfdyMn zjW7{fyOXCb%_z1z_*bA-QOZ^J-F4K_?NSah&wIGdbN;BsL$kKEDCttYBKgdI`OnEi2@AhrSwXZ#*qZ_wm zAE%}F%2vqOL4AiQAk|RxMt-Z&BV1oekP0~ww#+W7f>MzH`bsJGu>V8n@^K42oJ_U! z8xFa+UmpfCk8+#t5ij)gzB=5)weX^TrcbGd9@(or+d*=IOzz?PLV6t&4k5BMwf2)#%H5jbT~ zq97r(@Ds66$&U&blbLJxxoGrneUc0Be?3$$|5d=5a(aEk7Ts!OI;h9%(bhwp3=yZc zuvQZy7C5yrRTb^cu^YCPuQw-lbk^vf;y?z~_OXrsdYp@mwxuwods2Sm<_&!eW%@a& zXS-lvCh#UmE{RGnq;ZX^R|na|3NK_6af@%VXd)NFtBqSN%a>LTU*-=H4A9~bcge%5 z$i+b9l&}=XnM09UVF_`0$4~iaq|aN3hp{}wD#(nUY|sY-)}At|3nVOvU8_`23x-TM zl;6}sDf?9i=+l1=ml6jYIbA%*yKi{J*zaU^c6HWTp$rDnTi@WD;Q#B`DG_H;Zy&eq zcbt(kb{Xx|F7MdwSog1zUUV5J+gHKQw3qq@eIvm>`mdp&f3bi$?P#Dffn8oPGG8zu zFm{P?aV6p(w&S)Sfz>ldJ7_DhUVOFVOq@0XFIvw(dYhb6olKh-aW|P8R5k~hFrNx< zNQy9@qUuYH42xwLS-t73l^lQAWg7=Vz1aMie0f| zuUN77-mq(8i6t=_O^h*Wnnn|EjOogr+23c*F2>~E@B8O_bKPBb&zYGs<>}AoA?9;_ zU+qO;Q^V*fL1)23w_W6cOi!KZNiCNw7e1<;STPPvVB~_3rbvVJSOZUFE$bC&V%jq5 z!sE1w#(qJj#apRJ?&O_4=S@Y?K;l1Sx9bHM-)M7q0E__ zpRJp4Kcf1H{fzM)kXB!eBvl$vRsNeSj;8gr0FJ&_CM34s#ooX+JGwWL?diAYn_Uh# zEY?5>v{`Zhf)m+?g!?@k`fGHthdc*~zyTP4Jf7V$UeH&|cs1*|50cvqK3p$`=Jxlf zVN$Jm7=uxs>N)57#C2VJA)$8EvNcB$0T@8Y)tvO;SBF_82J z%;pRbsjB`A`r#vQj!AWeG?H4fZ%CH<+7v;9>23EKBERu><96V}s`_3(o4%saUO)|TahNn_;TO8?n&I9gj z+gdCUkZ=pSW=Ub#W0Or+(>GVC++4RI!&q52(n`ayG&#IHZ=7B z^30rR%_1X&2?G86F+=SZEkZN`5>Op3goT3_a6>baDnhx`4bQO;(%LkzR-z~Hipb=4 z+oA5jhbX&W+BEatQPXrqnMdq*=bb(J#U_cVqAUAw2nnJ$n$^BdI_4mNqOah}`jRgv zefkkeJt`<<0P9=wnx-~VPmZUxT-cd~&~;!F6@xV0s8PP=TU^Ag&GDGLLbMGOabY{z>d`Q^&p1V<%z#Z(Sn)Doh^!|Qg#v(PV}C#{5SZDF{Z+!08~j*_rIT3>I+u zDDtPj7w4t+2Be>Rt8L@Ym%MD8umaI zg1#x%gJpx8abr9nZ((UI?gJP#Acb zFAB)-r19d6Zpe=9Ur49i7%qql*@~esWJR-Q1m#n0hCsW$1&0NXUjrfIOu^zW(PSj8 zgPYUib+-1y(h3~eGkYSwclMs6!|@d<>}h-QwLGXz=b-}amq(BP2s8A_wI^z^;{^V6 z^AE6JMrvC_UjX$N>T+jx2ZHV4gCRW9kiSIX<)}@FYY6Rnba=>Ayd7?fuegq3(*Q)a z4sQ46p#X#{N{ZF7!=sQjIiGkNAoN45@b;F@54sj~&Ch2W`>S&Gw?o~0@z)@t8$^B? z#3CnGdigS!TDG!1kGES@wPXD=1fNZPv2s%tEml|2;_3$CirH&7$2ZFDh$XGSq*tP6 zPLEfd)x`aNm%l3fu~tIzWI8xT@2bD4M{3Cv&g>EnC$QgCx-I@teAmdz$}JJ!9VSQBFCSF0i_?#<&YUz!Iyjb;kYBWT zRTOdTVroR@vaztndEwtnkU!+NTXNZ^D!w&6P_v)Hgz6AE9iI9<*?x3kS&*V z!6BjLAPXF7?VPsu5DU4fg!I)+DHDJM@&rgAdYfFEX_jBi^Ud9{-1#h18Vg08gFD+` zz%drDN(;_PHM_nIC@dT-+^C>!Q7-q2<6IZPte%oqdBsk&8!`LP>tVI*8j!gpU~jq0 zbJcmpp!KzTcG>b(n71HL3tuYQ{^Cl+o2&HEL6jaNsTb2o7LGV=99$g>-*Ja9kd5y@ zo1VM(CsO$qPQG9JZK-Wog{$Sk?Q_4L?T~yq$k#$sX?8X_7-qr?^+ZV<06XG z5EJUInXchN)np?MDJILxKQP6v0#odZt~=}PEFs_iN<{8i{gC5|-5*ooT!Sk{y?&)T z$5 zK-b|i@G$D>B$B^}^yCgp@+{C$U+v*Eqas)ZXlMu$(7n+-4m^6o7XJC-8j`SkcI}gFa?2BAqdR#< zENc~@gzLnvylEove?m;sJ0wa0X1)^N1f1o;0EyU>Zg{dFP5Sk=2)#T{ zi4zcRR?~2m;D7`XG{W4d`0%r(BfFev>AHodWQ9HZnS)8$4@~LegxH9(2c=aXyR>nk zUIb|ZT|#>fo#SBJOl%%)D5dm7*}=0kC8SO-fn!Mx+|WS~Z|@{GCbWw6x=sh3Awsv@ zIF2P1gZ!rEpuPdxpsYSKAHL`HU}M_;dTR@MM+_62k4JcQxac7?Zk|8JJ#BH@erwum z5KMDEn7k=FmO0Rj)`QyT)g3T&z8jJ$8z%n5&ukY5TZF7@2D2bN*YLrI({({LZr z&^&*XN2>+->yFq`Td#Rnr?j0A9z%YT2w5~ZKfhkTzO#J^eVExu5FTMX?edFqsd)c% z(~kStFVh5?(`q_x(Y*FGQS8GE7|(9hmjmS1_sE8c#CUZ4FdBHYJLgkaL>`LFSs@q~ zHY7-cCC=M$$K%d19x2skkgK64+}k1Y_3^z02=}JUVdmsKAaLD}uz$xT``Qxnozy(* zS5_^FGsn=wmT>PO2=~q$0&b~5VY!3#f~uy48*t0SyDS+}h)x#=@gO_%PJMuG&B-6^ z!v37Y4!PsEm}iUP({m>j z=}-qYqG^;tpt))8nE!?_OL1VZcZnfHYzr~O6aQbt@Y-YxO4#?Vb3B^5Hp|{}z(qf5 zWuH}iuYw$wjf0(c%z(LGP-*rOd!7_T>%HEjkwa%ntJYr_Pf7pF;}V-rJqYDS!wlP1 z$>|}G%A`^)X$|vJL!B-A!jc8?Hi8)OPS~&(yN=Ow&b6tlx;6B&IO*Lp2D#jQWe=0s zst$ZWwcoYm1neSqhyx$}=B>lNIvR#&(*F{W%(&^sIv!w{fowh#UP7VLplo?~x)EI( zV9kZaNfXp$QQ)eA4#x2Lr60AfXjjp1OCz<5hmO>_yWmO}7tw7CtA0evg|=A*6KZ+V z-o4ktLq2XC9S<9lpCm43YwK40HjAzi28|Rb%AasFr{}^SAZOlMT!KX$lo3h=iHP^a zaSA-VtK%RYKA#UIh=v{!$uk{~}38?Ac z2<;J@mqu^>B@mfs?dsI=Zk2v0++HWx#C-m=pQ8C;o{Pa4 zolFxUS`gp|KF1kqtAz&Pg#07&1{Ta3=NVAhpef)4>5bI$q>p{4u0g2%2XuW+J+_rYr+bdEeaE|E5mC;ck&sJL-)`q;Rj(sun;0d48T zI?^;LtJx@-yk{APv{}rtiQ@;^G6*mhBW5rB?d*Ye$=Z-)1#=1S;ooD5jiKM!w`-}5 zNq%vz-u^p5L?%jZP=I$vtK#88Ykl9uHtnhWN%;;wLa(B>?WQ^M5ia{s5Mo>K5iU4p zPlV#G39}CZL}J8Qx-q1%A;G(i~m?cB>BJ5pOc3H<2%7c9DUp`FW=k>!qXHDvU6a9`BiMexfk zi4C5V)4QS*(jRK7O=`kGJL%q+@i#IP#|h*dB*=-76-PlT;Hte<{Kq!q zCrg9E@t}j(Z3(V$4ESt&>pY*P{xd_I?gn39CpIxns%m}$7=1vCBXoH}l~9Hg3XDE! zh%^)I118mX=!LhBVxbqB^TK*=joKRg3$D*|;U`loJ2=(3d!Q)QE!I6_u**IxZeMw~ zMHbw?wWsY7BGb0bJGgy2h{JS2?3ccOH>J)9m`iU{{pQ~YevdCChIRv{*;@oZ(32WW zLD?ot+sn<&{}Br{w~-Ztnd33yU|ArTWiUYNyabDm>Fmv(d5?!WdwFayExG=!3;V&Y zQ~to!?zNnH^(rg!|16X|*;G&@kV*GvZ7qLTDu`E)le~0F%g0m>n=VTAr(MBOZwHy| z0A}A^V|AeL*t3W_;Zfio+)60mykN`n;BT^g*?w3L1I{3iyUr%k5f}`g_3;(#J~S%! z?v3k6G%TLA5$23;I;;_VDkj1l$#14l*}c4`(-)JFy7jZO5`%qE@zo|57{nf6uAxZC zgWp*PDgr+uI^!G$M@El;YgrRSe2fPE@Wc?sef#{`4PvQV-Fo>wyT&(^mBVw&R!Q=R z&OuFEh9>w<9=G%0$jk*RGRs=4y#*?J`2&N-$k4AzW)IE&m@qj`O&CEY}jv<~o@_khSYikN&G`=bcBaQEjL<96ZQ6 zhMh;XF$k?%gF54X^cqkkbv8LYEQ-Z&D1HQ$8h)e!m{13P%w?aNU^?=}bk{jKt|=K? z_Bl_61S`!D<%?i3RqKE?LCnw5+BcTF5b^;CPjEVD+*GGtj95HyQC-?RV(Fk|&*^~Y z&(#X_4jm5VX}C8&&t^J$Qpf^xmU@%tQ`xv%Ee`2e4Y;*zTs3oxroCG*M!15_g&iMb z9N&S0y&7if&YpDdI;T>UKHk)`1Myc6I29B+E6wV*pg&z#zocPAoIiffT53;DsfHAp zvIc*1h8NkLbfxD+IJ#jTWOiM;*} zEN%!%hgkw?#vDCF78Qka3>*iD9AN!=qtK8oU1q_s%%#Ue*~o=Uoe)a;W!#15{>0O{ zQ>S5TU0nu`?G_4OtLY$cTAF;sGQ(eNJN43$(6f619zf~Tp@YYZodmpmH20 zKK)W6oIWE*=l=`ulPErAC;QCwS#)9j3Xe&i_YOiaNoh0Kg&qzME*9t{-+uys5{?eq zDGL*H|2@+$dk=|74y34ANzCn8YjF`q1%jcVI}SSePqM*jrQTS8=+hf;)s&s6z+A8= zqk+9RdU(MSk2{CkXS%-t7ZO*IX%(7h#)=Y32by+TXa>4bA?_zxy0Jby2vbd8n0o6W zrQf36lA#*vsOA`2wZe0{>s)N(W;t8;I9cFFg@GJ?)anN^z4}|W$0SQQaXDCDJ8nBe zStV}O18_0>;S33QI*NFoW?w(W*&j@o1HW-4I7F=ZC%F?igfDlH6NFqT!4mg|T9{$1 z_66}lbf7*&b`iX##jJZM`LnKC&P+`fd|2d4J=gxZvfc4QIy!>chmb9%ga-2_mm~~X z=>>g^kUf{acc+W~s_@xlE=QT1XXjZf>bkAz9lsdODfJQhBevm0WH1UWhT51{} zKNaxFx`&|z1M(~2>ESZCtnE?{VJg5}R=c}RyEUWV8vl78p1J7b`H&2EBK7=j$&jrf zo|mtzS7%Goz|~P=j!?l~9$Wh#xXFk2x{tU7k1x-VI;&Zi3+?=NLPZJMa~*oY!_8}D z*yvz^Yyft22~@!iQv%8$@lj}jsXVyR23wXOYhN%J!Z9olXdlau9&z^~j^A`7ejSe- zbN6Pyf1Asm(spv!(yqPKyRy==bXSN}m-ycOk?4ZSdDfyXdwS<*_Bfag5U%AdZKiH( zxTZtyf<)T6(;e)TW9H|S11A70$tOhb!4vHGA{u4cJG@y)v+#;e053Sh{;btxypId< zwiiq2rRpnX?KoG$y@C_Q?gZLwxsl*T7=0p|g|F#w1N-22+&E|nu&11Hqd4!4P1zct zZ<&vQit49}qLU_|!Sltml-*BDlf!)aU&d34fb>n$MW9db!#Z6N&KUqMX z(I#+f|ApwvF>BuV zW7DiDgU#_0oYcqHRTpDpgZ+wum{TpeSK})R7LpqpJ$wunzCx#+`Nq!S$Cd2oc~!~m z`_u35$r|8k_Ev9T%$KlvK*o>>%}$PQsipTim{oDAwm|^FrkVC2L4s)F z*r3XbrDccH#4lw#(1fGerOX^jp8n1B;n7?3MmsvBC84>wD5sIva9QEV?GRdDv!4iU z*CH;BJNM7ABH;_nJdZsvguyKG53i69CyiW2)j_-Re!D?D!r|mK&{8+{EaemrPd zmgAK8%pljO&83S^+7oIRosvd~a@mQ{bIZvN1UR<95Qnl>!bzl#;^}$vfVPYfVr$&Z zJg1lp_I_5?jN^>w^>h5#_xaJLU44N$UhE=P9Q{bc8gG|gZLIoG)L_RmGoc<>TctVz z|Fh;>X{(Nf;G%^V)t+YzH3v^3E0|!LGCGv~X{exa)-L zG}qZ-M)#~{J5RXMJF{hC`;9xjv%~cJY?<1B>rU@(hbC14#h?@qq(Q_;5Kuw-xORX? z-0k>}k{y@{k6`7%5R6Au4|7a`o~Z_6Okr#`Qo=t|JDaM$deQmS{$H z+L9w8Z+D&N-qa;AyYhhJrni8|rlvLQ?8qkJBF96faMqxZ3O2l#CaK{7fgoXm-a4%i zF$*V#)h;4=z2A<#_8xZxSrLvGgWhXHYPTVs@S5?yYCp4M0Nd>%3PKa|B@5$_$@i1}{oq$zBQ4ERxg1`wGSrr~2jIusRW zq?35l@E$8$I@t!<3-amDeOpJ{+WOl`PHUOE?io_}rO@8Kl5K<9-lVg$5Yp2}avOAq z7H;a+cuix&$Z^smyPnyp>kTne4i>?)wLh-s<@E3v2kDXhXR$plrG*ra!jM|PW*em0 zkinKf3f~HC;7FmG7RUFYNFLp|>&-KDAt6pU64sEmaf@}F(q-&u7h@><(@T7HgDz5s z=){Jmpe&Fgs0(|K-J}7;X$Sj`-c^C~ z%)zC#3LcRfh10H#MVJ7_1h~Sh%nV=Xl^3}r@kJi{(}{iXAw8hxLGUP`J0W-+RkLvW zN)SkU=@$+35gi#gZ&0xLKqje#l=u&5XJgH^En%0Vs7Ji(ylmIR=-CUM9M!ZMpEAIs*$JpjSHR;=ukLEak*4NHWgnD4O+aVUD^Iv41w}JQ)=#l>=nAjkfdwoXZ5F4&O_{3P0?YAy`!CdE)-D&LGUc(+o1qk+YfFI5NP^N!gy6{S& zn=tq$`#FkjqA`>-y^?-V;Ly<{tNLTMU#~^`1JHgm*-wj0#ms`nAT)(fCwB{={3;Yy z$bSO{O-JsuyMD{EPfmQoy#O~G)gjWDgB&cZd&Kz}ZF8p)_m#6H@%ytUP`dNIbFB|L z3F^ma-`@OG_*yb++Awq-cv-lC*BapqFB#6U9-II1;OS0^y-OIo_2}dsk=W9#Hn*ZZ z?a9akJxOhGQ^dKM`Pn1cFC2E}`RPvmu;EkZwhKomly8s6fL8bw)=@ZABy0@sgM&Pe zDjG)4r?e;G)QYTXGsKP9^Ql>Mwa_zNM}qHoR^8#xbIF)xD`k90J7rrYXJPe9a@vGC zY2uUf{D~g0u-?5Qkq+ZXBE&jd3>J~vId(Xx{?;3+MDGR#BcrTp+%H?9vLH2Pe>?d7uYhZU2r zcaxNRlTh`AjLGX~XP2H-GS2~~$CNJi?o*q&irE6Y`|Doz=R#3vzp$_>KX*>WL3Mma zT6_wXKEIoGIkj0oiJZln2bupP4Fuv1yeigg9!oTs=5f<3r8V$77Lf{UEm-)u75i)N zf-i?Sd-{`z$q%{g@eIUI2UlNV|_rn-$8Tb(gxTZ zXKO27g?`_ORju4B&)(C(=K;p8yyY+Yf1V^*UyMbeMC%2p|K#kiS(8o8`h z6hXz3v;x}pH5+L_eZ;z&v{Au&iq0S@++YJ12L7Ue_#^u+q0DG8?UlzPYIP;K&+d{q zI&UONe4`iqnz9SzV>*yia1{)SQ*h|I)}n7M$Y*s`S3u8w|2@9v&b1y=5p2^uO!4MECJX8tRaR2^`c){taC`PJY^kv`rTn)M!Iqb_uf$tKr`PT~E+yg(` z?Rah0tXWmRQ)0ZB`!^M%i~m|P^$YfEL_G-xx*B4pBN>=#9xe2}${>>+4fK!lM_kZL ze;zc17f7{Gd(F=jZVcnWL40TM#1rcraW4hm9k7mRLcf-S5)QDsI!KGDUhg`-vhQlR zA8i9sDRu=fVU#Nr1iilgH&P+}WF+m3+6zD{B*mA;B@~*hQQWM_NmlnAxWdoXk#s)R zFN&or^)ZA7wrN<{g|u|IEb7^+_9Q@^q!9Idd9 z+Fbg3?mv-fdOAG8bw|S!Oh3fzlbj|Uv%9ACw6ptBC|NmH5a*8Fz{Lx`B>gXsZ_x}e zTco}gTF)0{PIq1s2I)V81z}euiQ((QI?8>z6Pj#H#0tfmRp|^w{6LN)OL)WzD0{ep zdlO`9>>#Hrnz(NbFEsMxcpoVS^-##TngmiLgH!qjs2FYs^S(uX0E+MS&Os~bc0#QzGr37k1wYg=WN0)CKB?&64 zpDJ;1t$4r{WkFa7<08ByTg>x5-bRb|ppA?}&tO3yc4~x}he9C%-BZZ+{^4ljKE8D$ zx9A*u^jbF4y}+6w{|yRQ9f|A13s@DqsOKZ{$9~g=8jpS~dVOtA>84mHLRGt{mlheV z)wS|MS*y%UQ<~sFr>j3krD{|6OnQx}Yit9jDsuKARe%NQ;vj8k{y@cA{=%w+X~|3& zea&ogZRc%x0xhd36vP&RiM8yAgF_<{{?V~dEwwTFObha9yLHy6a>OqDa^>9MZcEbU z&T;N!eU1u})v}+g7&AsUjzH4?4|UtXNa&cF(xkY>6QV$JIfwEY!qUAH;t`3sVA$5H zRO%bwh|*I#tq*5f+cXN9quuoZU~z3&SGg~ccHm>GDg9M5rHa+8%M}xC1^BaSNrzl| zvsMLjfQD|FR8$3{K0#Bq&aD8H;Bb$-M`4yp1syJt#K|Mt!%4GB)k=nSJaZFMu2l@9 zrSJru-DWhXP5*Y8T+Ll1iG55e(4p2~fNszrQ*jWv1J)Z}R!HM~KCS+~cXw^5j>o(N zlU|+g4Y}^?TGIOPCP^HBdyLhfk=n}v2c^|jMJoMa(aWnY>^?7RMbZ+}N9TlkL~R__ ze?uq2Eg1__5#<_KaISAfA?=xkuC=0HQW8Gda?22>ubRU_5(urN0TI=ccuSmenl=um zIiQx@i*T|Lf+_psX5c5GW;jQRFfl}0FG2d^}v7r4SD|;bYm|aK&qw--laVnHfI%9y@Bf@AER4J_Llw588?N(U zY;V#Q=1or7-`k5GV`ia5(&Mxd5|<=l;T+* zm^e-6!+R{*)@AIN636^o8Isr~zeUemcW+6pMr~aPv)-v@lc|uWelA{m+lYsz9%va= z?=%7l&08Z=3fb0q?AS4AEnTwh##>wFTsk6Vkb9_4k6KczF?8DktzE?9qFte+d?s;z z-=1$GvzcVm-m(ds$QQ%Jfy8b%S`K7mFc=M&Uj`EBT=&Z9aY-)Co1{6+cS(&gWTZAW zw3d#UZZ6+UoetZQbfeJdW^4+jsWJRD%`$YlSvtp!tCol{JiZT*rG035y{Jy9-EWm| zparA+BE-Aygl4HfLya0cgK}e$fli@ArTzR)4{fnx1w{`PLZ4N?enCq2+vSzC)96}t zg#qrAW>Pm3V!g@;x62w(51rr0?SLA2G(ubr(HpIe$OxmMZ8PHs^l+{dR?s{+$lKE1 zB8N8a(WEN`t1F&R!HwLKZ{!(i zMj)8orQiR~V!E7&NOlb|r2F}neIa0OUzmn`^MllZD(-Xap^b9&f+v1 zY6(Bqq_|@z2PJJlGw;3EQ%NVI(H0@5pm-cI$vn1xNA;?m=;h+Lv@M* zZVxdMxvEO22br`v#Ltc>*}ZCiXnT16no4(X-R}+VC5W~k94iRwP6txtSBdxb9b|V~ zJ|L6Po^V?xTDx9)y`sbsqj3B42?w5#+K`Rb5RQ5f#Hb`2-VnYzT#1*XZEbqk@P=%7LpD=UAeuJ>T7~DL zo-luEMYo8cAV&x0BhM>7qilW0u(M(U%A^rH)5nDUi5a~lL|d;0@mB=xI_o8PI@M+q z%B_S`g$y$nns||1KbuX2P#r&c*x_+t5uk$n=zWykZ^{6>`iZg8Zpw zs2`4X!<4TfFK8Sm9v;YeL&ap{&WMu{<$)|Fh-5u~e)uq&jU4%FjkeJ9I zaxHLPsiPGE_35Xt(p3(FcP216o@%dPe zS7L9vRjS5-!IL~1b2-2ZH--G8IMS;bT{=ymW!*ZCAEwlgj7qnY8`h1=lysdZjLGjf zVR*Z`&5|2MHU&>LZ-M(S5^5tvF~odw0*km%v=-OcNFp1IvzKG)#Cj$dbQ}3ntexH# zg|WOgMhq|9%Y&-F6u%PgV0XZ!qecBU;lixD%nf{pfYn1v;U?6G_&JpNMX-T3U7)xCjCbLn$L3?D~sA#EJd% zon&TrNCPlGj5?k)MAU7%4gA*vYQ=kk4P(@pa%CgZNJxj;wS8J;^cm#*J^iI)!^AT( zy%9>wRvIzrOX4KKR^DYl5!t#OZx{BSkXAtzX%< zGKw6#>5+I&UEPC(hpp4eEz|EObs=4b_RrV12|h@_peE7BuaPgnP3#~ogk!J}_^1;E zz8dnB0HF@7{t|u~L`#Jv>5MicgFXxg2Rz3I{D&*Y96HCc1HHYCaGEx88^?Y;xuATX zc#{@4YH8>EU`%s_46UAhT)rr@NQ`eI3{3KCdTzu*L=ys_GBP}|QBtqel6eAMHi0C@ zVS^Bx#t=SsK*qp9AxP)}C?jfz3q~sJs%D?9{<6~%6Ny{;P(1MmD`sPnv(2heP^yGe z&=EV*Ami`8zKar+0Uvg(VH?g26$DO1FP1 ziu=moF`&bW5(Y_>sb~);g{ELVV44dKb_pWi~d4A*mthc#$vfby~-PTE`ETYCu4sG2=gsg zL@zWzD#;YJ2MK=u9N$`gcg81lL4x`3+7-jt680ETiA|rg{rocX8CFP7nalpc(}?d* zV8Wa@44%eb{>{^<&319BFj@|(IY}H|1OGaz69VYW40S>vohgmk!+Pw&&aM=02{Ql= zW6{L)*vnkRvc8jsiw5`w|KzV*zGPsn;Fq=a!ma#`D=!>=wJm?kvI~1b?9DgS2jr^x z1Rs}24GXWNj%%l~m(vEVVcSCkhz|=T4{>P;E*)dN)FK(gDV`gM>#X83qceVci0gcV z!*Jz#^)dOv{DIaemr(#1rYtqMkp|wZmN(UVusinRz=_8uA48}aIPF)Y%6vt;ml2ofskl{sUanIISeR`zTj))HOt4}z9kj~~7`5f>;VAbZ%CfV|h zunynoE#L58NC5xE{L1?_?#?prRof6~%Fe zDnM5&lly2?v~}P%Wmb>qjXIaC+Dpb&a2ndvu4FAG1(fzg=N-u?l+(2(hN1yDXosw{SuLv zY}i*EG;9@%C8_3%yakv7z;BCN9o9bx#J7vTI*8v_;L~91@3B1VE9;B8$6Er-< zaP9siI^TQ}W5Pa11Bm^kZPe_PsxXoob`rG{N^jn@G(#gS%^)HR7Y-!n1J&|YRqXLz z!k7Cx%cfUtcJbv72cR6{7(h>j*W_Ffi`xI*8`5USP2o7X1;-l+wjpY&c%A)*=i>BJ z5yIJTpFJR9;tk+?Ky6V!6tCMjSbqh>VegSP>`XPD`MTL``dGYYJ`RafA!Dnb@FYmn z_u^OPN4Oj@s3s6W8)EuHQp`s{645+AV}sP5b?8P(*@27C%MEOb6c;>jnwo=mqSh9# znU7h-18${yD;{J*Iw;=<>0nH9TStp@uyHP(CK4_ksK>;U>{mz!oa*YJ>S{Yy)~Qvr zD9Pd-N$f6VYh~NH6U2s^D#bhIxu_ZHpy?zv&K5=1g=^}!R{h2hH9>IgdM#+~Mw4 z5l4h?QpM5cB7CDKrKZiiS^RPW@6@ze{LcItim+K_3z!8E-@z7{ZT>?VQ031HBwYNC zW0~uDTzJAqNEl* zq~GRj6Y16&bgD?wn-5RSqZt$PX(k@+i8vG4^+z=65Y{PhJ_G02UhIrCDy6OC4dv3> zg}cSsSoicqGJ87}x6Z(;o?F-MvrvkzKVY&g5^!S$+6pkb`3Dxv52Ljpm%4ccU-JM-M34zgXHZFR-*> zYRO8~KM{e!&yQXRSO2{880VyvkXZC!at4lDOUthkrqsl=`jL6Oe59!{GOt^kFYp5| zfgZr!XjI4gp2(^4WnTndnZ?p(fozyUaaFYSDg=c>RZ>`VAbaS0B>SlEm4ma$nOS&} zQVEzq@&t{1!B%JtRx9YrKC~g=lFw|CEz=}G00kGLmlvdDy8hu^UwD=` z`Nfh2>?yjt$qedM^V$E>^3@5QI$E`Sk?O;k!LCo{yIQ^}l7%y0%QzwXXzGUPZjHXd z?pgE=Q#;Z`9_jz+7bWls}Cg`;?n)KpkNC-rCUf z)SBdUkC5=JVy8w=*%!Odxm~lRv~4aYimVswjC-DPi68etK7_`_$q~$^D6KrP(&LdJbF8Mj<<25yL25v1gUoGyv9(qHq{+gxUB@e9%7Pu6w(tvh&Uzc z0N5#*M4)z7pJsZt*Stv^H_irU?`+`FaCS2MXbL^R^fzyk@wn_ZLsFW#ide^H%NB8ruz9Yqj05Meo>dOahzC z)|>ZnBFTMeum@NuFIz8PTsi;12jG#pj_u}w#BP~Y!y>CcXJc83dE37!tB-m>9F^SG z>AG@p?V_EOl};0BMk1NBjfz`lVpx0FFt*veh-)P^a@V`sE8F}(wbu#%LwP0D=hz`u zX)e%~2Z8{bp*HcOAFxA^1gZzIxn^7QAgoVX^&7m?>Rk1y+0)F$22C8Y2NB^BlvdVP|m95n`%`te8406(@2_4Qm=P)gP z)los>ZE~^-KOHfTG~W_0@Sh|I-KL)Vg<<;_N;x*<%~@<2N#lvyPu00g#p6r6%h}j$ z$61`Z9>N+ovxAtz7;Us{bkn(ajHqn+zl^BWr$8kSAhPcrA&(9DTgVI7ggk0$rkX(j zIgTf14qQ8lHHMmIlO0*C^R@+k^V_oAMN2XG4QvhDk1fW1QJh!$aDK_dnG8BbcA@-L zsooH>s%Nj}dEL`GK^z<|7~{M9(qbV#p{qYzH+Bvca`PY`XVkAx8>bT5&ymEX5MdaI z=Unl7^91=Kr((pYH`bT|)VVAB4eYzT`-*;p`YxBcm(A!}Hmzjl^sdvV;+|t-XI3p& z@}NGg^fNSB$S1Pw!>s`jgf8aT**1XR=yWURCIJxQiS32f;t%#Qp-Tc?r@4uX?3>pc z?_Ud_K)nt~4{b&&+(L*+;LFDU3pdTHEtGhh%JC{aTr*=e6o*CPb&|}bPS^u4YG53l z@y!zLn-aEB6R2)LGJT(agI)4clZ8%;N6oTagk2J@R!bS!H|xba*ys0b6xy)5N)xs| zQGZoGG@s(jj1Wc4ES`m%G(6Nj4XK@$}Zk%#F zTwm$;@hd6yADsrng3!Z$9O9Sj4Q$zw*mbcHOh1Y!*cr zPyH>CTk4ux%y)juls@4>6NAFixysfvdV}62rxtsUvql7%6(uM3D1PU&e0KC&mliIh zm+hGKT$$^=j5E$=iTN}`eew1qX7s-Jg}GYhc9go-0sU=p!ye?jk&6MknhA*EUq#Ck zd)JB_)5x#2{~md2&(M(4u&|7PoA}nZ{;~%A%NgAo?25_=kk0p<>d@GUh?%zC%BWKe z>cD5d!dEFo%(Cq@mF5T{gViR^JI-U7-4$D*+EnmUevrptlp%uL*E?OPd=Gg zcKBQM!6LF)_~w1GfGiZgg3Zd5rru``=0h4MFe*meq!&ydG&mUe{JhtsM);1 z0M){|geilq&hAI246tp`Tyg9u4wL(47Y%JB`e95hjXuKASw9CvY7<-1Zj#FV$X z7W+klm=8X3dG+Gm>MPngr3Dvrl9RhiXUky3weXbf)AuxQM>Cs4-_(?xP3lSQ$X^qOu!Hb?!L+W1^KWdfh-;`Q9m6+w#U`>l zM%7V$gatUxg%=>Z1D8j^8ekO^z3JJ~ddq!#N3M3>m7ke3B9EPD(6Qx(qs<03S{Ac@ zNs5h7eVzHS_smB?{Q|WxOh{ZH$=v$v$z@NCbjS#MFo0pe2r0eux%&F7u6>*27Iqjn zvso!Y`f}J|LUK6Xm z8tUYFbB;WT6Ca{*#Uj*$oi6xsTVm8^+4I+ck5)ew zX9zu|pS6vPt)UOoszG^&8HJt&zg_s6xgI#%?bZBB;!`aBaH&gcn4kNI13D4ftrukG zR7paz!CnwE8v;U2_g1e85Q`-V3|@_5m&kGRAav!zUc5e!Y2GY;Bo2`N)C`{dMAo;O zbYi_7Da37YfXD86o7s7GmYv_YHhEppzFC_{GD(6fYf}^H!(kKsgZ;?B`Xft;_5owB z5c>+@(rxSZ)`x)y8Vx?82koEv{SJ2d$!DEkpMOYR92Sea^rqtb3#DgevCXg^gbYRr2Rj?x#T0|o;*h!*;VzyVjuu5re9vgf#@ghFc-+*SmHK`9-eMQ z3_+bT8sOFhO~q<+Z)CVP=X?A=wp&ih&+JZTP0O@(YMS7;PAcu!b+j0Qs@;DzZt9(o z5$cFsf&ERBXkn|4J%o@9nkcmGIjHD$!;rASLOh}zqFlYB(er3=v$;QdcGK8Bx;1ca z5B9}nRUcUhQ9v&YIyP|dJZ0sWVIxI>?MJQXw2ag~sd~3ll5LQ+IV)U#hV;!PXgrM30JhB^k8bz_E35!a88 zO}EX7%aDk;nXa1bIDQKN9Oh4|oI*Qvi~*8wQJOHdai@8Kd|!*{;Ddo9lt-{3 zo(1phOlrsW9c*J(C(y?6(XCeZ7%9GNNyiN&xom%M5`}|)8lo?>RyLaZV0>Iwf+}a3 zJs5IPwFc@rEzwV{!0g5Zsfeo%y+QvOSYWz5B)%D5_Hy;Tf4yc#c=LuhM7c zXjbjx>VpJQ#~wvQ91ZP7-G*UomLF^EQL#ABjjRLpUWl5iE7~oR<|nowZPmN9J~suW z;^KYsLklzV0j!-KGMf;~W)DApyYKR5W2?UCxm-?JOW0%f$F^;#zf52ghF&BV!pp)5 zEo`v}qzi^&b#A0uIz+3PC-nM-BX8qM*zSaT$QVKd2{OAdCzuU>cKKZ^00)3rCoO-` znVg7VZPMwRvbQ;m!=AAoXrVL2yBO(^Mw?N+93gu=Y%kO!T=Jq#{$sp|QZJvJGyJEg zI95Ezu8@T4RPih_ck1(T4#PMfU>uy&{(Wb#IOV&>6?fUwyDJ-iS0uU$8%W*iCgK(L zIdunXJc5XoZU{<|$sl*!XI{**NHg#C|irE5fyCSeh*zq%yQFTx%nt zbX6`Qz%fAxT|<1GBG=eZ5MJp)g5M)P6oz)Dq`u`I`70);m-T?E+o(EvVq-=oT4??cyW2TsHY@CBjnVYppZi1}kr&wy^ z5}pVHd{Q``_|x7%g*ShAD{ySl7vDIXit>_Q-uT;^pdBuA4rJgi?sw3+a)-FGKb?u= z<)imqWqXd!wf7Mvw-a(P)LfeWH&7SC*83OG_g;w7gQ`}&G@Pyn`|8jP1IC(Rh|7k8 zwUaF)uf*;ch=M>#js_WON(Von^t;=*xp*p)@bG}YO%U^z#F%9CB)~;_t?>d#(Z`)yH+cUjf>md zp|jakP=E4;&LjMf?S{zwsH*2U#ZX&S9C-jlxh?UKi=Y7yhn?xa7f9JNxd}+0TU7+K(7prIkWlcQc4~e`eaovuJ9nAqvw? z8xF9A>_2k^@9z7~S@LKOofj2^_uvR_!o$tM!1=KGxZ$O`%e)XqdXGeZ#Xb^UtADn@ zcbb32l{2(QRQTb928zq!EyBM#!nt}TXe{(mgc_0{Oo}wkc=bwX|6FMKt7ZPArMM9! zEf|+;Gq{p{@rn8opG0x8brQ+jGHg73glN?9ipPVU5nt!OFPwy{`L2D(m(1EH=xQAqJ9I-!NwQo1x?*$nVrkoU z+eN=G-%7+~(r(qObh#_->bTo>v!A-ve)Riz+Cese)WRUROkm&`4O;O7e$ElWz_||w z5G?fhEw(Mu=jzxwX3k;{vTnYxm9j~A4(!Dp^Hw2ari8~@++~fJ%HH#Z?SGCp3H>UG ze9WQ~;=51r5qKyUJmr#rjT8c-sKMQOlqtFZ*d&(_c#@Wg%qWFQDCk3HjawLCE4Z#1 zQ)#pZP_&LYHMl+2%|7u2qLZ6F8RTi#fPMd2B=h<+mIPsJ2_Gx+S+;mu;+eR=ej^{8 z?MvDc`$e{!*pnTt*p8bB+j|#~F%pl&X}xfx-g-|s*&=I8wnNXB!`{Q&jQn_TZBiWO~eAirP( z#hI8Jca7A6zG~Q9TEIOvpdn1F>W8t&06>KH#77K7v#&3H?cn@PQE$bW{r=(7iJjS# zKm1AE;@(3Y?Xp^SoZ>bsecZ&guC{HHN7Runi?{dR92a@G^u}+fNzS6B$}4}VOX#Q` zInYzb^iYK+d#1E#Es#4{sbbb$Oab%a9yXjZi~!!Sn;A z5poae72cTZp;&7uxcnVh6*Y;9^@QP*Q#0uJ|I9BrQ%uwNAJh}Jswt~=ZSs!9-(lVhBFyct-6hmtvwK*BGwk_~4 z%Q2KpHXh+x9NXIlk&?Vm%{C~*N`h&LqF8KqBh)Z4KajcY@N;O8x^a)KG_Q1FSehg3 zgq_%TzK$D?{KcFB5PpQ&9XisguvU|n%L|U@j@6|%kMnk_-HXTzNuA?A(P!w+23c-C z$UNjCjDm%M#N0}Kve99ir zr8AAWi61MDq<$*#jOo_!Lq$24gh$Ia|4#ieE^dRaF;40cJLEy$OqTr(eoZ`D70sRR zGz}-xE7m}X?L%b6>{=?w;3PFAk~!hyL=OLA|1OV=R-j9wHgZ9k-;;mWMQ*HfX`T@1 z%&Q`|>s0;yKPn=}E|1lVmU74`tVA^6OgBUimQ99*w(K%X;yzcF`GRwD&$lE;xQOu) zew)&Mz$_=nqF&qTjjw#)&G+)C_~W+H+|nhHI-zAtuPxOR1#z7Ents$t6jm><-J$V$MO+KRg-ryT zE4)I#LE0iJ!RSHebo<={g+4*n0dzXB>Xyv@k{0wS_p+B=XHDH93A0O=gtl~4!gN=w z+>ksI2f(6dXHF>6_H~7klj5UORu&w~D-BCe3J-HiRX=bf0^vEG9FO6+*wn_AKP`cO zPmyhSVl$GaVkIDdX(gCj(8k)+iu3Dzrp>~d+vgW8THw-wor@5T3Hj=8x)ech|0G4dcq}V4XMT=)cAM^ z*VfP6-ptN6_)UzX_X2kPJ~}M?=G!{$NbPpEs2{Z+Sd-gA_Y!gK_!2r|Vl`X(r59^R zJ`Eu)ekcE7E=`SR5`+SDm;%tK5HV5X+ju5TXyAeq)GQ7dCF8b)eHZ^XJbLXK`5G8=4ucs?dTyb${AAd3Ld>7K^9HwyP9zl4zZR*DG z#!JVPEJ1#5ht}<JPp^8CqfLua(Ei3etFuAT2AMwVfIZ zx6OY+_e=|Dm4_JM1G!~%p->h^BXx|n)+qu? zM`I&+a3Ult;)b!#I`-Ko)2{Sz))ObabJs5UBYoTtTy%68d16H6F3$$N)i;vpG$d9O zn>9#uph>kme$SXJOnxx^ck*Z7SyY%XrfW2Ds+xPQzbO8A%xvTROGNlsBk_pnjHsw2 zti~v?#{}t?CRy|CALFCwLb2(wDmZL95Pyt^_O4Fe&@ZKZ<6y6r4cNdu_Icq3?|9cp zr_|(+S|H>0-i*<-)(;9zS94hec|#YqfK}v$4~1jWtmT&Xg(f7^1xEJrfX)iuO0x?dR))174gSAZ>|X+u{9Nx{r+Z& zq?FITcReX)iy#s=F6zXw;V4?4!w*NSksk-E)dvOPWxKbvthM2k^QY4PBkVf>qB^#}IdjX>doKzitk@L+D^@^35k#>dDmFwBv4RzQ z?+ttJE%sibCMLGndyTy$CdOz~xWo6GyNfaJ<^8|+;<~%;ojG%6&Y9B>t2?ww%Q5SZ zYyE&5^s9%)D+FxZ6<|VoqXGRq!<>QI7dRN0p6OBqDD-&(znzf3%fYerd2(NKm#iHP zUKRO`T2Nj^F$n8^xl5tE^3JrPQsLgMG>!sip*8)3_c{6e6<@=ycPuUep{uUauYjOD z?#M7*4%6>Qs2O00;J9YSgsQ+m0*bciS6Bn*rSIoYKZgs$`{}_1h}?5$xR6K7X6Z9L zQ4?}g@0l(J=D!McC}lRiaDn?}{-V49CX_tC?Ut6!q@{C08osrZwl5G?qwaiw;tQb- z4j)AjXs{6p(L&wAJ?(B$TxAyI;qD>s0NKFWEp?V8Llyph!8Qk*@(XjfU3)|ZJARM# z8ZhgWuOqRPWb(gcsq&&HD-ErkZA&<{4*hl0P^wK1ZAL0G|Lr%LG)h*k9~&K+H7~GN z{F!A3Yye0V-dB2$>sl1E6M%?wS)6GMK@m1GadQg>18>wA2kYurmd$ry-V}Cw_jObQ znfrYeE8AAR&$MnKE01n(R-0FJZ&>})QJ0StqU!ZPRQ^}({`1Q;@}H2ha1|`x;(`Nv zFq{2E2!&ApQHF5yFTwms4`CBoR8E`PfK{SlH$)z|DonOCe>a*};?%`!8_xmk6Qq8xA8qq16@Z==eU=Z<&xXjgdtjZ~|wLtG@? zQ4ox>xGL|@>iZXdU)R5G3=>~1nUh6*wab`T6m)2ZRf?=4WNQVWdJtZ2ve6~@aDI%s zYlHl0CN+>6vJF}~OJ=*+T0GSOO*wjjbqX0q90y@l(@%uEv#66|P!$)jb4ViMMK0kt zvE$08LHswLol`cS-^C{}O5Bw56TjiV>UD~Cza?AYWuw_A$z@{O$@1;P>>Kh+?kP!Y z_z4)cn($pc_bKFe@h_AGr}UgzysIdgl#KdEXVqX4)J$mL2NWsL8jQ%=6fZ$W+QP!; zwREv|<4+@sN1#e zQ5Z1_?dyIqRi6>e$Fv(DcI<{hQX}-e5ZVhxbxoHi)UMjP;Y~-`I-Et{8* z-j*>PlrFVs)?=Eh0_#aqO?gZ~?Vz?3y0D}YuA$V7Ja3criJlT0`+BDP{9lH@mgbIW zT%lzbNt!*nRHaHSQh|t&qCcc}P`Dz{;#9RkYj z4F(g;qLUz*8`khwg>A4UJF|n3K8N1isXMoemjv-r883PnJtO4#*SH%@S_HW8mmN~V zp^}+woPu)UP>*F<{pX(uC?PAoI*(uJ!|%FmA=eeNZsuC4byp2qbLlbvXh(0Rj*ykd zk1nK+87?W4MzRGjkpeyHkHv%eLjEW@N0!O{EsjiUSXO;Ofuhx%NRBG*Uu$N|CjCKY z%K%9-axx|1XpT zq0=VZzdCsT7kcV#7`p7NKo3gsAi$+v0|8;1f8a`xAUjD!i;WKuV&6=<6pj$H#Fy3h+<=o$}?9-cAhUT+&Get`e!K6Ht_UH2aC zrViw{ukaP+#qQc<`G_zAx53uH2HwIf8>Z~5L=JL;Eqi@KVL$&B|Ii8FTZ@qhrUgJYg=e^RmVo5*Bpwh{? zVk`cjDPtvN&n5b!Uc*7?5i&{Cv_D!@WcY|xdg!MT*EA?gH%CLw3dE%e2@b-&PaLN2@?!~W|KG-Pfb6uYCS2a z_3>Ba3;=c)X-|7-=QDIwgWX8Hk-NspzGnw1mUZWrNO;qJy2;SD{YH)sSUE4!p1{eXDe>0_taq~O z+6_QGBl>Xe7XOUZ5)xR(^hxOh>=upYixl`+ps9(w&xBHsa2K(qp-K>5nf#Ie9$ENJ zB!Ate{mEpv<k2)Y-$uT4U?N{c-T7kN1LKI05#Sf<473@X4v1iE9pzH2mfY_Aq`vNrqdJuf=BKF~ za*@6%$Xq)^d1r`hR#&!z#+^{~omyA<6#-_Z?(krysPN2WqbSc+3YRs!K^~zILBbv6 zfm(4vQdOZY;rxYLFa9Oh$!Q?KMUFL+aO1Wy=2_&Tb7)(63!z=x=&hth0U5U z>QFleyWGx7Ia2p06KZ}(hMWZ(00(|@m5*S};;;8#?+i8o+J9$e1M(^DHQ2z&eu521 zBA`&ciIJ_bNRglL_sHPvCJrN*1O5CJi$PCpa**FZRXo>;cDmmMzUA z%F$j`%FZ0M&YRzL-%1WEW?vs_rIxPE^Z9fBhb287KT5cF9$aXl-+7EXfCfxS6fC?;7=rhjPja{O!l`^K(1 zsgFC#pB8~sJY&)OIf1fCM zblkcBD}S_5>Wc;dyWb-wMK93;>p3`pFyn`!mJ)1ZE=E;lt5P2EwR|_N+v4O%wF;Pp zrrj)Y`c~rp{wM~ny<`2x{(k*Efj3>ci3{>Pqg*Vp4(wX#Xua(#$_DD5VGGbZq;@0Z zc3l4v5zvwGpKgQuBA~GiBlfno_26fIp7~P;Cq!dcrZS&mM>;=Mci$Shv%#Fcqi5PF zt>V+CIIFUQq_L6Drx)-$vOJ5}LN~c2M3Obt9DLi*tj!^wb7xL@&3@k8Dov8|CpQS) zjN>Y_Y2i7r$2&N$LiLWvu;b`VA2n$_gy3uxufay6+hJP2xa)FNz25u4 zhwIo&OINs9hbN-@49OLnY+BONYjCT@tLXS`QhIk$PLkTCVwglYWD??qred-$VGL3i z-fRwhQ|!EyfIu!7;*0Y5A-%VtevJy5NSp#QrQ;e6G_Xp&hL?zz40H0+__ONTyc+yr z8m*+3J#Ut(`MkrcWz@Uy8|^Yh@k6YFtgy~U_#0deyFr$BF@d=Di?2|0K`g#P5mC`_ zd=!5g-H*S-O?==rHJ_UmP2SNRu>09O`6b^)vv?ozhegvn;+Zs8{6QrB6)emimGLj5 znzM*$(NSe08V{4*1FujL!P>v-5=DH0yH!MFolXw?u~p%b!}knQ`<|jFQ_k}V+aEJ> zPl##U)5dN3<^VQc$*o+EvFf$if_+R{Gc9&tnCQrq-&$gOmr>37v5`3n9X6p?Miu0L zUYSxw3OvN0_T{xWIurPy+%764Ptj^}v><&*YCLzx&Pb6Dt8n%OaYPpW?7LhO+fG40&nr#yD6o_!M%-2Vt_uLcA6g(xcVw0M4Hc^%;l@Z zd6Z_G&m&nh#tO@reyBqSr;Jp@x6j4e`0fyCpVXpoo7Cb3&bBBEDonQ`Z6F-z)T1m! zj~7tNU9j2#`ke zXHjwWuReE0?bRB#jXTtC-;um2+2P)|l*~7FXdy8N5``VW7}Pk^71=_@3?~F z{XJ|SEU9sHjF1LEUTQeT{aYF+9`}o$r%MBSR-ArqqmPU_v%a0G?Mc=LmfZF8%QVyI zpxHZO^cGDpy7r3>xgcOG^9({3`0w%m$JqZmC@|`ZD$+M$(-yICf{mHf0H~-i>;^zs zb=M_>@L=ZOtcxB0ppLkaJMH^+_P+e=gFTm!1f|48w;W!c-}NVF%Q&eUYuALb_oD{( zv`-6ARQd;1esZi;29pMkr5)LWfqJi^m#Qlw0!@)o9*LelN%xFUrx zqSA)R&8fuU>1R7RGWY#+y5yXEYrV9o&a5aZF(Grdi@|J7Uwr4D!lv;BZaevJk!9h) zKQGi0sWFu zr1GbH|9n64_WMg-``FY-tlEj|qJ5s@R(9b_L$S5{)~vy9!t5h`g7pl$i9Q3SmbqWz zJx$V`$>>3knxbI0jn$|dL-bhB(4X~MpR8Gv*26+5)So|+Wt*!kxf$!fw>xqqD*ZxE zR9)EU+jPaPHHmhFl!48(Xd5z>z-F;(t5@ zLA`DierH<`|8n!IxptDAx>nwkl4a|LR@Fo&*KEG16V{#g$}7o*P^bAP?F1rqrRI$W ziWUxneTdt@*-ny0f#XaCmJ9lw%z(gPN zDM6OfWzJY=_ zARR8YL5JaP8_0+_0V%HGiSjV&6qb6#Kgg_Q({-@iIbM+-6#ADf*QBK+4IM5$Ec7o| z7Vn{FO1A-gJ(MHJz*Y#mD-u9(#6=LExD)i41YMld9k~%MYDTY;{PXueBuqXuWLttg zDm(X73>{l$Irb9oSgo2fLPT`JxO;_)GI@^7245S)hG}DB{70zD@cwMLHYTn~E2dsy zi*W?piV9_Gl;bV#w{1FjMiKmClJSadTkOfl&=u#OfZ0B~#BC2R^j}boe5-xp(`xKV z%C$##95C~{L{~Q-e1JAs`(Qe`iG=$D#FAS@CkUgKW6>*vwQ^R3N|A?%l7hF*WYz^C z=}QBd3Hzdu?M>|K?9w)r`sWK$Z28@+0VDTD(&iA}-O@U<@3@uTFyw6FuUD@BwTIVs zbAWw&qAFBZQTgjvx=DBQ1$xzX?h0AAJ3mKR@J&>98)?(A)lleRtk?(sslx;A3Em>A z@WTi2w=vUPrQZb2>_IW){hi7CmNcXsMF;S6iX_L@Z{Ev^tPG>C4;g)`v+b04{`3&} zqM_|;bXyRW`K9bU+E=!0Yyz=1ajftD?vga*))?Y-u-&X^1vsb(QMS=T70j{x`rQVT zW{Vy%?_=YBLMG%Js{AKvHjO5~dbFCSia)xUpg&rOvZ8z_2v;zijfF7bh(Q3dK8T0W zXkZJHD;y4woW`%PCRFMYf5)GkF(S3Zj=v*E5<&Lh!Dpq%y{6zm03GTHz~dqk-yzR} zgizA9I8Q(@1%&YLL%Eo(RQVmhSv#%C``Flv{P@j3o9Id<-6NlRte+J5IiVO(6R?FR zA#9uK?QR38E_wQ@PsIcxv{8I29V7*jOOU+a;w{ez zekZ~{zISRGzmt|cYKm(Oeka_Ig2?Hu{7Q5F%x6m8^2eX}c1q0bp&&Dkm18~nfZHWJ zdBxZa(pFFp(cc~XRH=uxnfkk9Ry~+kmtUb8;sew&F{x3yv2=m64}V&cNsSVk@@KIX z)&~0XXTIK#PH&fOwIy3oA;tCQ9eXa;h^(WaIM@`j+xx?wGnZWGI>D%msnA6M#?4b$ zVoAZau$~Cv$%h1r3I2P%SSV{$!=nMe)mh)AzO1M~e#PA`-2SrmPW(=%)}yAl)L?zE zU}`%$P1b&d?mvJ{A+4AE`Mg+uuMG3@du8%XQi5sO2pcqXz_Lw{Kq3DJBx2cMX9D%W zyaB6cCH*~W^XJj}1(L{mAC&EQ{-Q-d$P+)6q#QqBByK>qi$9@g*1_SaG9o8x^73?r zc!2AJU3>Oc2<~Ug1X|L%{J?S%(gPBh#v91>4bx$Zt%e;p8H|D=batj&Vr8RIg%E_O zL&#&{XslrR3A(dH=ru2m9<;FcG<)0j9r^ENZ~Xe%+Ma*xo@ub*m!8(B6=&s`8kjnI zwrV)Nxn9qFd&ho5=9Z;N>&^AV=#|u|d%HMf&clXseEYAx%dgKq{Tr$zhF6LYbKY9| z`1lzsDWgr--b8N^y!NG>CM#Nn*pip34XCaXpvLhCHwKu1)-4HgAfjZ{VvzL;*?|IJ zHxflUDX&AOjnj7id(f|UA1j7)E!#1PzkA_7-N~tcn?d7b<-lt1Pu?Dvw)#`bhEM#! zPG0a5l-am$SHl%jW=~$)QA<84`+{@HFl6;Hv~={K6muylq@>H_frGr zEsrY1V}A>S#+1(m<-fU-V^N zRjI$LH1@CMYiIy@PnD!GpH`TRN*|RU?zda8NqS+$J5t-3n=ri*rk`q%sYTa6h()G; z#=^4-tcdGT2-@g3F1be_d$xx2lE3C(f91)X26dWyY{t0`4y;o0=qj|qGU@D=6yDad z74u(7@-&oQ|LIrviO=H(DDt$A`P5G8H=45Yw0`Pa${dE9L1cvVRld`8BSgQ8!(uQZ z3QqzyypEjwF7mfy@9`vvdS-dnc0G1?qpuxanM)^nr3!BD26*J|eff`Yv>DXSE`k?t?}ea|e) zE=55X_|>LlSASKFt}MMd*J9!Z`1KVWwpGznLuo@1$cVAUu;pv~Ad&K)w*_U2vBV3y+ z$S-P`n&(!XJZeDLi)-{)XGs_D!sV^Ez9H zWy(&=yoZyy$20y;W%1Ey=|s*q>E&}$FQNn$k?kdqu>fb#Am==OdWFD0S|~C4%<_Eizy{97go)PFL)u}~JYJ2)myuJ!+ z)@XrDL$8iJed9OzmHhFWhW^7U`0tyr4)yyCT@ zM|aUNoFZuBou-(#02^|0bz7I$mL2VWy{) z;>K5b?DQ}R?Z^sg8NX3g$?@|45ZVpWwddo;<>i4ibjclN?*QFAt;_D_E%-O#y%;oI zh%Y$Rah7q?;UV8NH%akIT5{&sQheb(Ps!hzAM)4^Q?oYit|qg%hI3^$nE_3mv@CSP?%KR^>af2?CJX9-58TTV{ z3A+YUiHl@UwNwP0r=&^Big_VPm9`qh__)jEgD9sB&kZ7#jL0g4M^XGia1=hXiiJtq zi=)U?ZNbSFH6(sL#IF`5f2O@#`fWtG*TT*HHqpS%12$0%p@3)KjmUd`hs62c6irw# z2}}UjtwG!8v9%m?a^7ZC{72B6OuCC4U{}Sx=r7e(xV|MpT;LbRV31K@MAb<4xZ6O9 zjh56_b))}?OtFmadOB5gVVUV=$SqZt+*-Iy@Qigs8H8xXtH@XFrCaV%Ji^1kqdgAz z2RBn*kKEa#I(`tT_!MC}^-(Nru3$c^6RY z?qTh@xJt_w$)Pn`+OYA=uykldNUdta~^9IypVPE$hzGxh1~q(OSIKKDJJ$ z?xt^_n19LA74Np)%nym5W+a<_inqvv#Zy4rETneLQ%+gPdKELFxcGq;!DpeM%Djt< z5vl!zI;v+7tFBa-#JpG zgcP90_4(DpE{yN1PZj$+r`27+wz_nxH@}7(-$7~eau-VAE4Yi*s5TAjSdDJokhZzx zCmt@G?wa4?urTu^SLYWBpA+9)lTZ)c!iJ|S6AV=>g7xfcBdR-xQ4KO!ILXb5u7Z&C z)~S|gooeY7*>=0#UA;cL#M9;3CmxQ8~$CbWwqLNNV>V54o8i0_QW?4x0a~ z?Le60zLplnhX0cAu5P{5 zZj7`dWjpbYmoJZ<7C)yNqqe=%>&42%BbZ};Jk$uZN0xmcak}a@N2X5#u>nF`amyT? zg(CIP!(EiY3YT31mNrX|>7KSIrHcrNCD~=*@)bK3LJ)Rr<6#MjfjN~MwM=i=ka_XH z7LIB*FqE;r+yYINdykdnM@J$9x@I#ulQ-xhQ;FGeStvaxSdRRMAy{`vA?!iubx>3n z*^oB;3cszfnGMKEK4m2mm}wy40sK#TrVP}1n(5~O(gbdtD>STI5#(+1%1|x*)Prx* z?G3`m4iBM-u0WbA47LJ~x+hEINH>_U>94*{ehB0#aO*KY*3znf`W`(-7|RN)caE2AGw+RWo;w22Vn5~(n<)gu3~IMsMsYHai6*mR98+r@%Rv*57-^s7rQfV z`a1T?u9XBBg&Xq#|8#wsR{zINd$NWb7>ADuF^tRkVm*K-7}eUKWE$?M=R~2NqTPJ4 z?v)H?V@=;H6Z8T;9(=JLq!Db`Wcpr)5d$>g#uw|}x?qOiiE*UP_*;*sQ1$?H0Bpqq zBvg42G0wQRLqXG_r0n62Ffq(u6kcgfNV9Z)3-Jc&%_^)73lQNDT5{oMhCXIbG>H7# zE<*PimViNpXW^3>3xu)08WsFK)J6Wp^M2&3+g2()uS9IL$ypdzYF*jP>F}U2QJIGJTHVTj%fq0WiGsyP6+&h*HUW!TDUC* zSSBZJ6{!UH@Pb@JM0YzAJoL)=_<1jUqR2?SezaE8dMo(j@2sil`Rs8I$+C8rc9LZwfUjNj zSpFWmZ?MRj(t(ErisS}>u8V|#PK0gh(ZpDa8E$ANfLb2#?fA(f<~;4^XzfFm=X}Nl zdRsbe^R=?JarXXcL90J&Ty z3BD>UCm;I~4VDaVG3>4S7|GjVftVWEnJR!x093{84Q_p9~%*Lzmgz9K*KYQSgBR;)uhUFcp!~&cp zL%KVyr4lUXG*aYC%8t!#YNn(^&Uk{F zILq{UE+P{NR$H#BZW7*}l6pjAak>DN}k7 z@a%$sM#SUk2g57`;HEZ7Q{ar^f{_{={?5aXZ{eTaZ^pu6(5EZ^({u}VZ%HR;gar5I znMeG0epr2O^}b)fj6pJKaAu&`y2!P1<3Gtl9KeMr%oD2m4_N@?vv;G%+SuMdl5xY= zF?-}NbKp!9q)z3sq|nEU=6{a*F=bEsFbGq9VFAWP1hPE}`Bnt02DAR+phK>0Rdf~K zZ-)pwM<;-ZrthT`h_2!qh*m@m6Csr7)TXKs=pvAyX(9twBa>C@MZtyM&v(SM2#zQ_ zq9lU0g|LH#%wxSihy8F9UgF=J*dEqJBt~IO3mzjk#av&F87RgSPH90}s1T1EihPfH z-utF$Y(Qv*yppk|pc*U#fiwkcj@@LAFC6yMUJ+ZPU#;n1U#(bGTd^uQHPhvp`l|G+ z6#{u1{d+f_u8M*w!4_3bt5wz%f3Lt10_-4&T*uBKV1ZdQEc!)hqMU?50Nw&}mxU1( ziNJxv*%qPb+a4^oN0MDcwPSbo{5$d+<>l&qoZnvWz4v2=x3@IM-qv+l-tNm@*{>^* zG*X-9X6rCYIVo-8=T1)B&%gUdlDAO!sa4c6x_2&){O4$;prU~~QrB9^A`~_Vv69CC zv#5(E>>#E?Asl|i0TQ^kj1f{jZErbgS!te@zrxOHDKA=Z_Ai-Av9>MK7dSX~A2Kgc zKE&Q#<6{HfZX0{1rzF2Pme^HdSt+@bWI7FB^E2L09t0fxf97FD+RhMZNh#i8(F(oq z`uub6Wb$O~Tc7!W0>knVm*T5O0cJc1BPd_=hy1wFu}} z=03`_u~|v>%ZDf39JJcWp<5^ETlyXDIeEyHi8JpF(JIqj#>VyTo+pwWl8U%`5aW7^ zWVqrnJp?}p7wiEk+^|7Iw>8bds?C1b$HsOQ*(@t)O+hzn_;LPu z>}ubM-z?sZ_F9K4cTJz-W+0lL*;-`|JIHYqYPGZa1s$qYt|3_>IK!fASJt%)-^@EQ zDYf+>iQPF+liD_yrJZXMOP-eH_K`Tt8;YJQr-3GT;Y1_d2oHZCM^F4hVuT(BDlQh} z5DJiyaxV@!YwECAE4P{){oS?&z~D;qk%>dfc^(Y52bn`-*69u(CE)jxdR>QFx78;?qC_i{j#0-@_B&KnL!5Ih1p zFURD13?-t=00~?N_!io-$-@LFQT4y-#EM?B>_*m3uGS8Dr-yIcrdU}g^AABQ*Lv90 zsmp&4ynpVVrP8+NGV7v%DmFGJGJ7|VXYorC#$L{*;e(pCwPbfm=?4XpUJPZ0l#HhAWjGj;ktgxv?7=ragU*q61w}vdVw@>THe+VSyHIbdw z#3@~q?d%_xD0^vc{YbClVb-#fs<=*P^Q6 zln!Z4LTzpVf_W_}`CfBEgHmgUc{K72Nl|sGM=ONjggpxrhld7_ZO#sIZC#78O_Ny3 zN^Z4dQE{4zuEAR&>e~e3nBW+rj$3hFg*en6?%`rz{yrgcExx{2$teE$Ojcm2;Y&lD z$4CqIk=(q`bbASB!_z@FOyz%W+H=%dKFB?0^UM4X2{}vme(S+T6r8ErRWUq&6saGK zCw%>3S-yG@Fx)^@1`%o~82>-RiEu)75UQC#P{kpYTrNdL+}@H=vb+c=VjprO$);V} zKx+__jiYKa;@y({-#bgq_>cV7AM%%|qT0T`V2!uVSL@h;b?9)8AKW3a%LlLnh>A0` z1OgBvP5-uHQzA01Ol9g`CO7Ll+lC1ua1;xDzjgaj`vC1y57;~?IFnU|99wX@N*BfI z&sSyjRX*dJ4omFDft%u97MC@a`xcs0B`jBjQJEdl;2`FuhJU?Oc8br6)nf``saq5B z$rVdY=;P|>f*g0nX4t!Bdwy_3;w?|ct(`(^HGP%Ryzw26VwI^s@_jpr-Q0y$h9PTm zyDn)$&cuxh&V_&y4})M&W?cN*B1?SE9>_?mEC@3Zc^^j`FDNGSXtSP z?%r#WivyGF$;;7xI)CaWt)dd^$#y6CE+DzhgDA$XZ!2ujp!aBrjp&usBDodYc$z<2 z3~`bt+iFZD--S&xXI4T3+JuQ zs*^e@YpI*8s@7evQ_7tuw*r(T>Oh^f zyHuJV+>4CcMXbt!za}@-ejFNDe()lr(-`)HbeR4mt%Mdz2&F@u(FNo}-siuFysrDd zbQ5`9B3fMy#cqh*hVcgE1be8M$rQ8>CWbr!+vik|_rA^_?FF?!9pdWbiFn@^f2psSI%{QP`UzJ*v;;#qmgAsLBRB%Q5SR^o zQ#BaP;Tl0E6E8{uy({yG25R|~$#)e^+xhm-K}#GQI(6c|m`%Ksa*1he3O};ONIPJI zGt!5mHI;7ORR`!NU41ekQs~xQ(5v(?_Rf^0f7^9eOx zs~(sHT>)hn^_W>bQ%2YnP@6>$n^o6qR~xbEWeej{en!&FE?U3M#hGe+mZz1|2G(H} z3fxMZzL~JM|3a3-hrBhX&%C|)2fgEK`Ufj#ZAZ#%;CPQMf%^WDQp!= z9*%-guRIJoxY#BfJ5)r7@IXd$;VqMo2rhJ4g9i7~NTwi1bZ(UcM#nEv>??K&K zQIZsxJGTF1coxj59P3iYwMmER9qMSbZsRlp)^M=EF9FIPB0xFVXfWtAe0}pPAtOfL ze(f3O{SZOQ#>ydie(?@H2gi;ZswY}bisst+FW3JbX*wu@wrfrkd@U9(18cL(Eiz`NzGzAxXv%8*5et3Y7K5;>ho8C{oQ(H1}=9YSx@niH| zGlv-i+0eTU@34tN>;Phr!mN`Ulw@}uF`zPmdh;Kpe0HixXKw0!e;1GvR$3s%oYwrs zK%5S%F*5vSnzNhzj^6+nADpC>^ki^9Nu)WOY{%M877qv{paOBoCJ4+c|1zP3YW)8| zjuIpiEmAxFSN=;>bo7nK&ec8d?lhx^l97QSIia1L54J;Wu3haf-rTEjx>jMyDKd?`mN$`JJlTY@j zH3;C2*C7;9+Px&XOCdTpYA5v2Z61h`Q;}i*!9?K!;smIAJf z;f|=ppo$@*eL-u%=`0NUk3G&he$DA4C_%Yw+UlYdBnq4b)Hd)=)<{&)&|?;I}jQhq~+XzNE0H98UH_3VXpT zRssp^gPKd7S-e;UX|*(WmZGg?DSW=R(VW#jjKZ_n%7WS=sa@rlaf2Yy&#D5JY61mryP?=Vzc zrreS;{%{oYiE?==^cn}*_*q%RUeaA4y9 znMe;NzF4>VeKqD6mMx?$IdOqb!#C!>|60mIme(9Hq|S}MmaeD(-8n5TgOr8)&tRlb z4aSUP4;jwahi!W|Oui?hGyL8?#6_Fr^ z1Lt3H9dz{{P3h1uQ-qF)_9p*mu3Z?x5(lAqCSD{T)-19*8n8C66W*4W8=cx}C>xuS zJj~qR#863e-HxvwE5}5Lm+2m>&!IedtVN7^ z8V9emkZmMk7!q?wgbV)UA)tZMqXr??SNDmj27`NmP`az>A%Lp;)#xn0K6yRIBGrCL zPE@vEpHUg3@qU^1eQ1^os*hKVh_#kbZmmj;t=u#s6E!NE%M)2#-Kq13xD8vusBzs1 z`MGW*R*dRg*FLNxL;hM^n$$F*ao4mO_F>%-MO06oRJ02XsV#vs-6w*gcUtESO?F1T zE5~;is$;LxN7bEbWgj+gNl|2m#?C0WpEh^t3-shzog<{)uFO=Xi%RV8?UYhDxvj=y3!Us zLUQ&3aqf8VXwed8l#E3+gymZ@S}YW55}LE2Fo4B8giKnXl$M89e+sP{!z;98t||D} zbG#%vUC!0>c!jA9MJZ9^%R{@ZlAMs0*rYDG4d?et+f`4L6T@pXv!afPXe`xOVHU$w zk?JlKR3S=->(xEoJ%XS%h?_@ucND&Cic{aWvwgOmpf5Jb z`~aU8VeKl{aHVRgRl;23J^M6jF~HkGE?BBCYKaN#z){Nx7x0%!bY<0}cuM_K5cK^o zbHbwb6#$U}fB_xtE5=x2>TUn{#1`ifvu^0xxUGP3PZnS-;~Ikx{X6QwH6P&J!o5Lw zl^U+i0P5eLsCI9ciUEMNVd6la77^`qz_S~)80d}TY0w@P)kKp(8(oVl1`~YvABZW~ z(5$7H)Gpi3u030jZLj)=xi(E^EUTOL#Jg|(1RXCe&`KuFSkt?ySD%In1AH;M2Mx5? zjGZ<0pAr>Bzs7qp+6xXeY1=2&Ez8zWzO3{)%ib=H;VS)o_OxL~-^Y=w;&C$L+!1@p@hPY1WsjeCAL1Jo1d&yH`({ znM(ukT)KsYYK!L_MA#0(Uhscm5HY<2%`07ak{`1TDSY9{*AC{#*dNla5N_!~`wK&! zSEr*lo{QmLY~g<~5;524<&QcoZSw z37S=c4F(S!#qeOlZxEP|U$fvryTdlUSa;lD;BS6kXQ#?a?JAAa9mq?4`+eD;(&p_s zao*FDjk4~ZkvO|?ohj16)L}tWx{R^0jw+m;jD*yga1==mWOP_-G+$=B=dbyO)e7*d zSdCcyI?l89S(DPE58|4guB<}zyv)j%Ix*-fOFBYQQlqeXT3abAw`A$S8loX9t{?d~ zV9Lehg$mVk%yeTc46!gqLkN@rKkQ^i@d{s1m-x-4HZ`N^SAVuvqaOz@E1}xFy^ZP# zD?D7sT%5b!&8m9BRyuwH`A9T>dR(l0f*RJ(U;A|hh02J{gLsTG8L}IYDvW|K9+|=s zfSuxkk6#cgUGd<*T%LF?&EDCMs@?kWwk3aMh;NoY$;k!omc*!5J^U#D>|<3Pd3XHO z$K-%M8K)>MMPhS?O)OtNuB{}s5w2&3rG{XsdJ9(+hp37T6v6VQS|-907;I#RX~o3b z8Fuzw{PevlnR9wBbahh|>m;N_Q{Js{IaguaMaklMaE?qUS3atR45t#VZ&M(XR4oS= zIh;x(!0rMpc3$wJzB?;jS97l3A3( zscfjHx4_pXf&hfER+wY#nXa{g#)}D_UQE2&)85%-+2@&)uJy2Yc3$<@D%;eQjQLKk zFxj?i+#}!FMauhm!t|MshsaXi1H5@Qn2qW;S(5W}CRM5s*G`h>_s0?pK))~)3xhmt zJ?J(Ji%bXp(Q3qvQPaL}>mZ5NF+wa_(>GOo%Yva zKfPhh{Y^krMGGIqg!zFjVx}MzJ%VpCA{2{LEsUa=CdeDTw!|IJTpscQXWJztEh#(e zes4P$zT+?Fg@+yN^QO4YJ>}pqae}W(uJ`BvGFFoFp3Zo|?-BVA%Sy{uq~Tdz`bt<- z1&ey}1nHyh@x_Re$rb7$%rPk8ii*Rq=^EkDv8mPAFMV#TmCaJJS?T?}5JlQPpDEF9 zu#GSOr361jMU7Le_#5loANtOJk%w|P{QZp!e<2M(?Ui^KT~{P9WG}^DE{V%c5BJyo zqk0&q0&xlPB&r@T8st(6wSUACk(m@E7Ri$4JnH3WTXBTMkq&J(Dc8;;1%NK=| z>y)kXhOC@czEpZ&z*G)}0FEFA-ybB1Dl z`d-uA3u`nUP>C;5!Plah59jA(7T+jemWMu^w7LiCJ|-NkjS4LBQ43`@?Q?#m@Ge;#IN_Gp+S4Sz5x7DJT;We2j7!W=__r1ZV` zLd+3zpklwYaQ39@=?*sJVB;KSd`~vP1<>LC?w_Z}K zW(}Jw!VZ26NbR-ZbSXG{7=1ZL%gDny+7`%O>~`emDeUAArslRU+Ok&X!m#B zh6I3%Br((>G?xX@y(!3h)r$rhiz5f<_`%0kHm~QC)5QJt$@|c|${XYR*x59$N6NR0 zFLa@G#3xZs!Kvruj9S3;Ys4^IM@=v;u2pmvn@YfgMI_urBAHl7Ug9bNnuWDN91|$X z+xqzO^G~MT>S32n-hFL5q-D%Ef3D*mKQ>S$}L-O&0~Wxa=tBdM`g zqN?m$`EyWIwd#!b6D$qT2OZ$*pKP zYhAM*r0JHC^;%(Jr;AF;e<&49snB3iU%(NPmRMx*8e`LJ9ZnCnw*Gum>w|SZ^l|Fw zsnq~54}G1RXjXuws_Zgl)y4Ls_JfUK`ppBYk@$N{R!u;`|G*Y?z!p`;mZ%mfOoYJ< z#Lf1*{<*#QT=c{&hNu=DML8>7!r=IKk*Q>g2+}pau&-)91qDS&Jdp3qohsY>o;7Os z&!WmxY)>2a%}YF~Bv)`E&hcNJ=4L-kHZpd2A!<9dXfy$ih6n5wW^jOO^a*ZR;e!t{ zF_my+s|pzm*|nzjX$Dm>1d6*hv?|+1ER^3kviquAFpamJ)=8FH#LOtcf2&BIC%1g( zR+{f|XzdUb9hW?d8f&BA0qNTu8 zguhALeh_pqiAk*$^1Cs@9k~l&HsRrHSK9oB_TFoTlu8Us>sNAiR-5rPCLhf0(jvEg zX4PpfPMJ^Tc&TlE%8s3*L;T9WF3VWW24fj3^QI!JJ8#>ZM`M9*L?TO~YOu;i3r_Jx ztAXq-HVRT28^T+CQD-Ep!oLJ5<4M6{y68_%aTXg_%yLx86i6C}jogKQ*8@qJ@T?2( zvaV!!;7H?+jZk)#@4_v?h{B&g^e;s|rL0NXjDVc1Ni#jr3W|T`meqM7DgN*j-nbH3 z=lkj?r@1%e=oAE(e<_KjGU4WA7J+PVw7z7!0caH)VT{+`BrkS zFJ;`7!wSyQY+8z^0@yU=CY~~DV}K9O2su}Gtw9@$)y4(z3oAH##m@WlRDbH|&o>0o zuEL)#S7XyYe2~NTf85VsYcfp-C1x{|7{f&WI;#I#Z@sz%EueBlO#}X?% zRr}j}XH?zYD%aLy?#cYr92@sdyVx|kDymy5`J-AT$g5(SEZv|3&^&6C)oN7;rS5;lX~hz&jyu-gPWIxLe)bsJY5HC-J7#l8Uzt4m<@BmA z_#6O3M_z>Ic&%MjjN*PAoy>i%| z0z4Itr`DOC!r_8OE&lHk@EhBAP>c1aXXSZEe_Bz6d#EQ0&h9PPOI~?FJ?X z-teQPl5-rw3dr)7f0aTqD)NC1Y?G{fv#wV{_kogJYug6X+T;=DwFwUo+OL8xLZy=z zoAIb-7YLo^tP{qopdXz#dhwYal`7#;!H%&tfT#`K@YmWMx*#>gc9?#l zWZ)M}^$xt};`#MMFCJ1)6uy^iK#$S1NpqB3xRaRg zD+sN`vJpLic>v{}Q~Y$^#Y3kkVkD5j?r1@Bm{yA2#{)e;2x3X%0W1fttC7t}r7sL+ zC2k+OI9PlAvwA|S&yE$GWrwszLg${(2Fdl*t3aQq`XShp*nWh%B3WJ+dJS%-idf;S z^mk|6Bro#0eC)i7|94f0H zUj_EaLyPb&qA2nhHWb8i5;njPOsATJR(;Qe&0A5Ai)^uelmLZYMU z_IlIGLw1V${Q5+f*o3w{U3e(sSfc8*8DKA4M#Z(vc2rO1EU%rrtKpWrXe6+)*2#fg zXC_n2d5V-hQfq1quGfsD;RF18_LEpncK`%ZlNDghEF}h-xRv^qlsKfpg+nxA^|uDA zUk~ot)P9VeO|#}_WGg-vj7dH=f7P-5)Fz>EJ6Wi@8ElgDD@L=^S-z+NW3tt_xWSAH z`9&X#15j&Va04(W4iu;xEaljei%a+kf2p}@S2$7{xd%U7%LdEM)#GLnPsc8f4Nz*5 z@tP0v`eX0T<4%Jv<|vBegwzqvIqGq(?xAzCd}BR3q17uNl&i{_J=igf^$wTAX-q1L zHc}{p;qV_)WJ9Hgsu)z=>4(=int33>&+qV(yhJ{(P4msT?GInlnH%r&hO%#u3h^cXKd=x%8h6rK`r zML9Kd++yocONk+zu|I&Qx69Q~PT3YzrtR3SV`foMmHH&NWBq3^wqO*+SEvX$mdUXb zNF5jw0zgKwJZT(ar#yAvs0iu{1(VV{+6y&DAOcl041&`1o{`WF$Dt&JkENATw#)>d zc7s!f*0dz&le2T`82MCIJv_ES-BPg$nfCBRKZ__O(*~#9A=GV8mgBKEij16t7EukG z5lR;&#xgc_Ao%7;He9K%97Bvl#bVodM1ZIzW%64<(RCM{#{YpDBYGm5kV5W4YH_C{ zi&r_@)7z%eT{>r!Tc5tE(~M>Pr?CsWyIES54o@w4ML9ilZd@)sPils3av7yAp?aG% z7hp;?%yK?5w|`8l3qNkNZZ~++1TjgQ`qfLeNldqqeNR4+q-5G!FoLD@V(jLgn3)WE zMWsYyd6}4GG-#ohavVZ}&S-^}E^v;#6@Aw|zT~Y0)00)-T9e)L%}Z80*>n4*(OuIr zDsJ?y*|7|2x7b!^BiY?m4#(fh^1TfLrBd6GjbhnU7TeZ@vym)E>Zu&YL;`1G27x!s z7a;h#*lrioZZb>E!{TWs;8T{xb#6oHIBo)w)L92SF28m zTjBS*`uUAco6kezQ9bGUp5;e){$)c@Xx{`4-8#k?Dpbr`LAgbB>D7jWnud0cF004T z3@gfn^Xx1syM;5kTau};)$gYk`B(~yo0*ED20m7bN(ui0{v<93;n$;4w5mY?P? zaZ58sY8)#AxAvN{L8~4V-Qvx^+}J_6=1EhB=tm?L&qzRRfhJlK8J1zsZ7mD#BQSze zN``QoF|rpUXjV)yp*D{)u1SZ(YsDELP|rDD;dXW7lJvmm+uYwfFk)}QY=3jzkAQ{G$XwORd9~=fdS^u(d;!GpG)%6DQuFM z!3d;f_)a*66U}1km_*QX6PBP+9&>BuExA4;Dke8ACN>-LU_iH1bQ+}@kx>~i3M;T% z%{>ELXY?GwXTWnH2GL67^4LDNUb(p-;y2o!Km=O)Bw5!+bJ%jn~4%vs3aU8n4c>sL?iI%$6sUcCv$)0v`dcJVac=j=B) zhR?V@e-EeRBzCEYa0{ln(0fbuKlo2{RUWH}}*X0=Iaao7=E0@lBZSX)XGx2S*yphpJfe zJJ5YbAYxFzl+n@{Zm9V6(XJE1E#lBwUN7;Xt|!0e`A^PhwV#OGlCf@pUVqY;YsU5{ zrOCBg6E>!Y(ioB1;UQt}fBm@qi00+X?WyazO>;AblE*k|Ln7_ z=k9R)Fc}_V*{cMuTz(5Kk1VKvCtXO}#93CAAZUxVWTm9cmfi78)Gw&Rw(^V^(dI$wuPg`oP|aUg?HKhy>USamZu=g~Sie zCi8~|P7^q1G%p<9EF<~Vjw!XgPia5;?kVqKEp2Pym%y>3xRbUC)tC-bb0AYQkQ$qy z%!N@8HYeLFe&R}o&2)-s%$?I@JxWz2Y1M3sRmJJbN$WR_ww2}-<))FH4tHsAIl0q)2WJzFW55@u z*-kumS7dq^xSKKf8?7f$5!#s=X2i5bE^aNw-tm1?M)@=pEgn+WQ8py4Iwj9g=i*#^ zSU5{p)wOk$_12TX=Mi^0qQ>vVAVNc%rcF4C&`#ArGK$+Rz6GpS1T`k4F^bOc(g>0Q zmc=mKz_1!i_xZ=QC06Oy={WQt9%bgD5`6il_(Js#^Q z-lE%D^XA0*FRa}198Y8AC;9%H&LDq9X$}rK9a?O@ZKUPd8#r{;w2DF=%-@J5k`(%M=h(HOV~0lMYMiS!tgs`lcMt47W@opt$!U5BgF&S5l(DlcJ4RoT*{ASNNIrDN>^O56=`;*Nx7m(W1lh54ql3yp^`ggTvmJ&V@ z@be_4+;!nOzyi{TUeE5VI>-YMLyU%SicvX(5j#YB?@9`|_LaQ3(6yhh-YZP6pBCrt z_ul7ZcCJ1@R*Dmz<1Wo5k>+>gFJgn~(}=uu-jz5>evW1mj~v)SoS~9`V2L9ux!quf zxMu6Y%#1zEP&B*>R(L)=IyNV5a?W)w;Pq&5(5#5a3_cx-v-d1<)S1>HrelI-S~s)W z+FSZ_93263^D^5vp_Vw#o>n4PTBr3J%YNC3bK;iZn^l(j?vr>bR3<1hQi-QlTc&rP zz?AmNYWe|fuu80ex?-EO;W5BrE72(V=swytaYYJb`e#=+Wf$Be;eqA(W9+|n(+(>y5)hALqv(_bNufY9?+5gAww|fnmX|aO!nj?nXk}jwb$7J}ykta*zrW$puaH0Q>gc@FRgE#_h|A zX+y)0aeR|pIu&J#2Lg~`$a&j|c`D(R>R!@BU=IXlJ)tqMOoQeYD>`BY@!V|6g zD0wii5v4i5d?{g=nM4bG6H<_57T zZ6nL%yQOuX43+Oy$QR&SJ|;eBTg+=EM6GW-H+G4B?WN|8PHG2dQ(tpBN%KJBs2Q`$ z1oNt7A~_SOVe)XgyrSAu&Ve~h2gltHePs>#JZMnVt~hdx%wNyb;X|I}x#e^6iV6cw zBfaWE{Oh>6-U(DcED#kZS)u`~Mi_(DC^hPBYx%z|!@2@x0R}KeVT{l*6M2lw|Ze8VhCp2 zwiVNwmseEpTT)SF^q;`d+Bp)YW0FVnI}~FKP71u3j7BNMWZU8%pt4&Y1uUgxmf_QA zuw9E|=@D_qtN{-4$05a@m+W>n_P$9t?aY1baEK25|9YmYDuv52h-8gs>HOjnL-V9% zI!)SwLp+~F_qbJP79F4*zkp0_=joj*sYxYYBXELm=$4Fup7bs-5Mer#c>3h-NkGA4 zK*8;>+9>`)48`Cl^2jWs;bXw=V%T>sP~1MRSBCsmX_C?PqTP+pWXI@+*kKSA=`W4+u5X%;?C1#*)t-9a7YZ#A^>q+11syMp0{0V+^jNB=`L{)O%e zt{aWqx}p90*1l&y_ICaTBz8sS%_#< zEZyZQzni0-;=S2vm8;-H_~)Pbg390Ut1`ygJ55iXUl1Mdv`L+8(usB*AJ3hAX(}Na zy0>s5i5i+?B(y$sNp6~H8|L-mUa}^`l;7LM$Eb;n4oe>ylAc|=y@cbc4ooIpGzCC; z%km@VEMzKD6sH__+j+NAeMu29O%DkcOIS`j!%l^qObiLKKWMjnqLWtb6XQHsn^&=7 zrDKRR#Pg8dvT$O$A zYGTZy8*)frF5io$QNBKW(h~1$^xF#r^|b3lCoUttH|cjra5P?&OR+CyR=JBqf@(%v zB!%|cxCV}e$j${Spco#Wi_DY0B<{#90=r5;NMq#D z>dwR~`xZ;~UHjeMfrR|-D>`nFo%(XidJX@}=(14f%xkv%xlj}AFF)7IaYRM+YIzL* z?Q_?=y(<%&$MWA@=sWwlA>S9pnmRw2Mc&D2O9}sB)NBe*Dq`7gX%}z6!U^esAWXx= zuGPqh4N!r0;N&V|KDI3c;bT3C?ZG|>;!MVnJQ%Lm*mZ4lpDEvK6gbW7ndK-Jk#i#< zNn2ErmC^>!Y)>MMWmrSJ!%i7aW)ROMq!(X9iiq4rKL4i{!Gvxz+4-{ilU`H@=OJx= zE=>RuF+^)cLU>&RE zUC;slnAX{->_3*okln_DB*lkEkaVazF9pOH`1clP{_@l=7PYuzlmEtCmXL1G))y%0 zGN+cehRbld`E!1$meg}d)h?U=01cE?T+6c{+Q>-9-9FhD)fu^Y8_Dj8bR|Ef7Qsx& zyNh_)986HhNEE?oH1>G4NJ^amq&(5ZD%M~f|5xr-|FsTYJMM2>^Z8h<ELDhGYsv&>(<)^rQUiBS85z@k6K2 zUy?Rx-i)!Cz3q5sO?AK`k4TY9uHG*C;G!X!QQn*|us2yHx$%6Tl;Vm}{X7lv_I8fq zYIE7F-QJX=vMVQ2jeBevAm?N1l{;&AlEDSVN(_nR^@DpS_|h{ZsHm^j(@CVC5j!{k z$gHsBX#=@|6JuiXWBgqu@~IHqConGnIo#=-85%c@y}Nx(S$uD{SOl5-0)_olEPsQd zg)^G;I_Thnm?#Mw36s8=hndLP5E~~;%dP9Ly|g_$!8P-VVArI?10x|svKXvsGdI_6 zFXgG^lJtfhweM&tEi^26CHl17z2_{Ykd^ptxmvok2~k<^&*#a+%gw1tvrm!!%g3=c+<1tHLBI^yaBT3hs-;k?;D1C#`qr)bu1M{r zZP|&g2EW{?E{BAD{}-WROk$;m6?CcZ$Y)0Tpklj~#Pw!H~JV>mV! zo5^Apppp?qBNUI;9ppeKfnz4*WZM1w(^1-&wj>R9%NSDU>^S>UyU7~Yx86k3$Yfe8 zw_yfnsjGDc4&`{1T zl<&>rAyQ8nwoLx&EM)HX=f^MAuf4cwiv!KWTwdBbIN2@WHpS5N6ce52d7H!O(;@zl zoome$esd2+?5k(J@KmfOgKxlFIX zR9}s%0!stJd<0hL?K}C_EKe{Bx_W%g!cNV9SB`0MuA-I<) zx?`L|U>37R8nJ~Kn+K+WNCNq6ax?GNYeJ|M`7<96aZ5?qI;tmA>1>jC5;w~`BF#st z(qcpN_!T1eUNQZcJYNM^ZI1os=I?*Ln&SFtAf+l~fzF^0yf;N&*qi zp8c4~s4LUQ+dKWXbeu^Vgu|DV<(hfGpqtqG^pA++v&yJtg9An#-TE>W&g~+rXnI^x za#T@$vD|D0hOny&HJY#Qvx%qE19S z?P-PNluSU1JlyHo z)is}KK_}o;o4}fx5*=quvEcNaYk1B;A({p!(6TGh)}yB!YWanOs5yY>`|hV{4}LLn zf^G;jLlt~1-YH}P=9Gu0%eo*AeR3hx=^Hq4O`UTPOV~a*351N1)oIB6aDnW9jrd#B zJ;-l9BvzQXHT44}1cTfG0skF?z|AN`c$7{+uvT(|%_8O=Vo?mXVXg~6Tr88K{lEWb z%3u%|=vw;S^I%nu5JX!bF7#6hfIuEF1;I!Ud|;Us^z3d61byi5$4Mqm1ja}r%)z)s zV3%|VWZmIt*X%@_x34)X3dHlbB~BtIBt@l>Z@ z88mjv3I}zfJc_=!rD#BGGfz)1J$8|%1^9)>5So=nc3h(T+fT@GfmFWQ4q9}@kxt>K zpCz=aBsLkd?vGiY1#&C#i|}Cu9$^QSi7^ej3A!$}24MX|R${&WSd}t-%t9QOknH|0 zooq^jI=i&?v%E6b6>opW4nn(r<<*6Ii=t&$k>+Gi9$MPBcH#;hJYWOkv=I$(!PGf=0Wn^oep#$(yok zuqLE&(}b;M@cSb=P5WF$jnwH5@!&~fx0n+eA3Sv&1j3HX$?Nu%uUThLhHjm7YCa{k zSLP%qv_8!=Nk^s%+>x#Z%s3q2O@VKG028Z}2n!^re?(O%JpyV`$^Xa@h5Wtd-C76g zO%gs|ajx7=tE5@n-qh01rPCqZWnjXJU0Q9m@K9msMwb1!-UHsN8Sq{FT}f^sEquq5q zki0TDBPNTZegUa+y=`h2*H4e+hOVv{(H0RrBW>KqVi;OBjHjmftoZRFOYmvAfyugJ zvI8+$2;9mp3z(B)&yd((g}PZ+VZD)SLzsgr8Y3$j^?59=O}+E%=xV4#!mt_ zes+Et6<>br#FDw*nzS^ZNKAj_4(C+jN=Fu#w>s!fyb?&4i;Y-%QXCn#WhmwMtjn1b z<3F$Lxe;j`jjT`4z-=7|>B2^`mLw(TC(mS)r79!Pvk;RFQUY1A%aEfV0#(bzGlrHA zLn5>~fSna$jV7fg~&sX+0CZThO^T+`?^5+*;o-5V5(aqw-aoc9MC4cQx*b*hr z7uABg0G_xl@3&HOY|jzeNX5@l@N4<6o90hw<;9jgRg=2gxk-zlA&zGO4sLQKogjPz z!HDt7o`Zs;&A4O$hxl5ZCR zJCq@vp+niixa6_&q?D1gc*$^V*NgHf?l!0i3{ObA+p{Zd5VkA0F95j}BB-Dh+~Uag z<~kouD%%B9T<3PjJY1jihrB%ick$&VQ(gWE{PB@*deEf#HqaA#b_*CwZUu#2xh@+) zKy|}uPY@6?gI~j3cFP6a%VMNr5d@7;_#>kcAhm2_puCESP+^l~uIE?ai%geQ=e*hD z(jn14Ev>)>JF&&FcT^x_hbPXw+Qam^TMwOc_e{@Jkl_4ABHB1%f;^Ic3p|BgQ5Cpa z$v>crO$H+14TC$=2Jq#bJDoKzcq}-+V~<-C@t(sYi);JvWyELIk|dXve&H_3auq$l zkwtgV51*qinp6FK$8q9hYU%z+-m!$2t~g9kg=0V?1$3?#a3?=U#ub2a;m*CHS?!Dj)N` zwrSa`)8IGZ9OyZiq5ZiHWE>ef2|j<-=S1v+AH3YDY9HLg_6ZljNN_cQVNBt6LB`nF z=vbXTnTv*;BsprUL_sbVc)*6y75xy+~QSB_Be5z zTL1CmoqJy7qf$0SEErVC@%^KQ_3`E1Qf5G%UD>#f(t&Fmw#CQAl%D^T=Z~%=@wt@y zK>i~%C|Hp41GSh*3!Mw^=bsVY00$pjd<+>6maB^aMqE6zU2wq@d1=_x$Zx z*EO~J&Y_wSH0pGCyZ4}yhSHPaveSuyVs!0@7Dr8qnDEKH;1A@#dH%+x!|(DmZhTqQ zq%>FeCwu3Ns_j0*5kpWcoi#eI2GA~tmr=5CUQr@p*MXik3T^c&3Y3BrkbsboYZYef}vws_}F`p2w&kM%e#z)#^pBKE%#YgsG) zVNKV7IYT*No$8~mPPAcb)~&2fzMC-HZSq^GF);MP8w~WV;csAksO5C^A?kAQp!w%Vo?!P2WS5cH{{XCktpiWfP0Ms! z{kHU7uJq7%i|=L~>qW>~c<}o}hrU0!@F0|jf08hI8BlP6a+{q4rau(fl;P|X4XgS? zQ@11Ii7&eb>xHdX9q&j0>0rJfa{YDmMFmf{R*P;UH)^mowCL({kif zsF}Nt(A{q^!+6@j7z7<=KG;|ks!sD@IhDqf66yj!F&2U#>KSD=8nm$GXWHdz!(H;@ zZfbAbqz&b~blHJ&MB-VY^9)h|DZ`m5GKho?hd&V*meB+&h>5rzzH#%=o&cwLGoq)s z1$mA3!6k%W+#U0EX9sb5$&RukHwBRXFE&X)2UfTGO0vt}ykX@nxYct3Xi-NB1S4Eh zn41N}C4=H{7Gtoz(L=7*=>Z>`lNcKtrW+9 zG?-9!Cia7C-Xn$F0eF%zU$sE%sxMssvBD6bg0#!^7~oPE zb5onk{Q0bYcVpTx5}i?w$dAhoi2o4Dcg&g3>f<*Tj@0|tvH@Thu?N6l9(p90q4kRV zX4$QkFO!JUHxcylk!;`sPd^*~}?wE(313ax*1QnJFgkn4o{y->S2<<)7V$-la zPs45Q-r?O(+dF(yGCNOxMR+}~svn6JgtPpeQ?Ac`#hmkA`o-M9ZR9!;H;`7yb)f&n zWH{d}vA_qV=z^BX=r~v~kw+5`zd-EdDD_Sutr#bXysn|l`j`xlq#?qKOrMOz$-y>v zTBG%T1DRbpWe}jOu37NLQ*IM!IOKhrTn!%89-E!!xAws89`#> z)id&e;3SU!uCv+sqGotNU|X*OGWN_>aFl7Zm3IK@d0?->RY92)>I8p6h`TtoCT0-A zUrDrt-3t3V>{jT^-m{Vq@>PrHHo4ii_>(!MDegb39r!1SAU|OL&&bw5`&O3@q|^`|DoO64 z>0GSGfQ-sQD@o#Xk-yUDA_h5;R{_!7COfS?7T4rdiQV(mm?eOR@trdYiWOBNAUcfhIORxZca zZSm9dZU&D5&gs#&v|jGlXdC~`4$y&Ygqln5>o{~=l(0VUK z;Xk_-MB&VO_5@BEdxDW0C7F_y@fnydNw8_z@Vt@l-N!8gT(G2CElO%R_0irwH3n10 z70IxI@Yrb7cvt#Hg%|QQ_a*xFfMF80Ifiq}d;l6Iz#{{gk(nc**oY-dw}sw**r%Kw zIegQGQME50oA7JjLAu~Eb`tq|ZWM3rSq|o=K8u)-VGH5gUh;=od`i-Hv1K{=79mcn+(qI8$&hTuV5*H#EK)x{n zF-T;2*4Rx>Q4+|%zxOc-GT)#Tndw!Oj!I3brf(tn3JSK;;aTZb{Hufvq<dMjk`;;~}R9%3FBBvpIAiz9}wA7Id`8D%>p<%6j1B|^Q zrL+mrLz?TpO}tHHldmiZGF^KR-Grmb@3tn$acB%M7f{c&$kNv+q7=ky1X4ryJ81KL z&ron8k<8a=ke|G5lUY<9B&!LUyvpBD*`Wy&EKGWYyavJBr2EyM5}HVH(W#*;GpmkV<(txq?4eu~3YYTqz*5jXnwt!;JotpauDUGzsd55hL#_-!Iuyk+B#Qe- zYzQ{5^`pP=P3c7rH`F)y*RqlilEpm9O(LrxCz>nxZQKUozSX}QbNL32u^U}?64J!^ zTh^&0>?N)-@O}*FzI3R7@JkLA$`587kiR{ER{pZu5@30mT{8tKmSHcuF6)_44C%nA zHSgLO8s!T{9TK5!4SqcG>4=<~me&%0_12Qq0lvl$3gZ*W6a^=mEVZbr$Xqv+`!YU1PxgCL$Lx6W*UJCZrWDcWabK4ApJ^ypR zURp;#&207LykS#!1;gpxyRW^pKpI6lOM{JN2ZQcJ5LIW(M1XC=T2(eO6gO}<^9tajQTUh zlv$E6gLfT^i%a(x{C>-MVLA&1QP``I2_8nhJ9K#_2=RKIDP5dDepqzcu#t25^}Twf zc&;TLA*o)%)UlH&jfkMrhjXC;T#5exN{c~~-sbnKwBnagTShSL6+;xJ3pIi?MYCLu z2Ic|^;S4Kb)R>_V^ZaCSmJ$OZ36vOhzMtFBD{m%}s?(0Pd^HJ=^WG`6OsYvNDViD| z$8+*gS~)m9KX|5GlAa(9ip&rYCs7b_R#5lm_b12Aq!qcts<}X)P@2q@)WpRg{bPPp z8mZ;EgvzMU*<4;0p;5u%B)fsQ8cmq?HBcA5co$lx0ZJI6ZQ3!)w3(32X06k+dku?9 z(IFaz1(P7iMM7~|+uUV2Yldgx^nx+8qcvacFo;dMZTy6|!eP_ri#wa+vISB!5Jk_B ziX}x%7?>`I{J!M)nRMjf;bXYKY>LU2RZ~+m-L!Jyu0^ye!#;WfA``Riqb91kAsK{= z3=Tua!sq#eDqj2oG9&KaNMNremNZSy-^LMk0G7|-5n`Tze;a3a!(V1#Eln>7E z+oV0|n0%Qxc<^c7JRRb`tbYAA_$ z4fl8ZY&b({XYK5bu)1xGH-ALNRtFeJX;NgCZK(Yi%9|;KIVLwKv@#YH1S2WBN0Uxb z_Wd*F#R7Y3f2d{ZV|06Cat`m`Y^d%vAf_z6$siwOg9qkW2Txdh!fV6xZ0uQ^sUbT$ zB{Ry&d6sTqVutxyOv2yTGl^X81IuRd2Z(*lImSi+FsSvUVtgF{ZNwji7629HsH!?) zW!Tts>3j80zTu&ZHwyVF{! zPrt-0dsqAFL9uRA+~HFbyn=s{cGNAHfxC9~M6ORjcHFE6f!7t1slN;e!#I`vam!QE z>;H=S(@R=O9$DbMedV@_fITn&vZG5_leLxeky8u@$$j}chv&ZMpSCzk*C1f2INXJQ z>)g6Rx`qmSI{fw+ev6QJg~5X_XrtwnUl6}OX`2w%Ld!t%enNx0Xuv`ZahE_K4bp!g zNJB1s`*Q8pK}V-2rEHyaT9`m~n~#!gRIi;N@1SMiOIrSEl|lT1I8#sa9{bLJ_!0$Q zq5)REWbT9R51@OneOt%4*nA!S9u$!fdQ zQ9{dWNYBTOEC|mJ@t-)z!`k3!`R;A1lgNCfFMxKo}L# z4(C>{H_C2?sTwiT*LPr6O+^vPT~ziTPId^Vocg6iaKy>GHi?eS9}(~Mva5jJYH=*b zh@Yw8Km$F10kodwm^B)#kw(B$c8OqIMQ4hY4>}ZH=4jifaV^3+>Ko!4qp@!`G__Bt zULvgEi%NyUzOMZi7S)U`;{pSTpKnNSrvVd+swbCo1(falSAcG-^oe!zfR@TNUz9lW zS7S9z)xk0LzK%t1lliA<_2_BDp;-;3*J>_(FV*Jh% zg_wm%x^M=GqYI~DTZUpu_2M@Oj7Ojn#{%Pl@=R(lGU{UG#Cj8AzDx$ib>%T6esHCn zC(^^s2$qR^LS+B0DV+qHa6))d3m5#B!tef9~vA%=$bVPjv%}|3*t`L zmyvYFj4>EDh2Lu#4a9b|-cvznfT6f8xPtsZ?1-^$l}>IL5usn-xh*9z{hY95-M~yW z$7h?OjCy`Qgf+tHF;X0@hR zquH1g53xc~DPgQ2le~T$6o2W_6X}X6xq}C8o$atCeVn5Z5Yj)zA;TCSRcPlrW+1#@ zYe%G%_=nA_Yh_7{==;;!2Q?(rub|SV#f4VxzK?F4mqzM1F!IQ7vaxaFz7{JF zC+1JF$8FNbiua7wLeZlHQtT7vuL_2`4-x%ecF%I`6|c3(1bM%bS58f(%+v2A3c+5Z@L<=DUGW>Ft?{~RxEwx~;u8R68P~kNutLWzeNr}lGrkEbtLmpxn(AB)xD5!Td)wd9S?`#Md zq%bx|zM2?1u6r(aBQdlhJFS!e<0pe#MXx`?X_8lN- zHtUHB1Wg5kcEUxmo|tpF)0TFC7RDbqNcDgfY^W#RSA?7~!P{#Z zNM40u$2|V;;NTomBp(kjMMdyoP(A_j|Ou7@(wi~>lY2n=fv3mL_bSlgE{*)QH3^3}wuMm~_*$-8NIPzbW@Mg;bWB5E2Q z$UcMz8Ka&Wn4pW#4RYXkAO2{sfHYc}U0!1o1&eE@jQT4qFql3U1Z!)A0e_6zd-fW-#HRC80k;39Q<%**JM~r=lO6K<-ou!0X z_Ko5rFv*S?Eqqtw^hNy6=I9)CVGIyVn)vTIMGa;%8cjE^T(B2uyjQjCUPOoH1IcW- zrsB+v{2|LqOpwWL%u2#I!oPMOhVK8FFe6Wa2Km|S@}Xr?G(!nf1Vf3wJrl*`WHUbW ziNaL`u;qWsZmtEE918%J#FE9plK+LC0>WtE{t!_3crgVE27@serqz&GJ+CFj`ClKDuiSfYGRZ}b;-8MoStG|${-y8B4G7HXLU!vz zW_V6m-UpULIS#>^u|EUQL?Ly!9)js2IEbZRw|Z1&&?@!sn~2+o)rdBjtz4mI?DUF^+`KlWG_^|LTKp~r1nF)1_42hf+BN0cWlY%u)%4>i^3Fg8>Uy49R5hDQ&H6%%JKq!CWrG* z&}0~xw?Bqxc4XgH$TR64fmIO>A}628MTg$+H=Y*(J~bMf={W6${Q@ng^U72}0HqnZJ-y+FFm#>v4m(rNBp zQjW`#qCrq3HD(re`s9Ro>x7fb2_H~6Jhci>y)E^{Q)_17DfJ2Nl;zidJ>`L?96veX zdFzCu%L!jb7pbZUPmPzJ1iMB(t!QAdUZmnTuHSo>=Z}?0hTFrjpWU-lV@}}2gsIHfh2C|hEF5+%l8fhlA!yY#POKCc>iGs z&AMOL9o$8@aN0QTTS~5ye#0r`mhN=!yqP%hw0?!$>V0qDve)YgWuye*at~N zlUO}91{>kBf>V*eG)Wan{=h3ybugp`1~Nl83pa!A%^GO~sV^GosYZP2fBU9lc87z*hMynX@WyCYP46$s4zH)ck7`2oXn^mP&Cvv`Y!-Ihf7W4eKUG*^A@qy~s}` zUkdLtZ6Sg9W`ZG=xR#XZTn;;W^HZx*=2VbLM}Xk3n155fWUX3(CQR&?81Xily82Q( zZx=r)tas5cK5+bf&)ysn<~d9l{^S4m-c_&gpK%v~mrRa&l>F;angc9>yC^NH@rj-o z?K{Nl32AAycX)lIPl2cKpV`}7=wM#px1jj3Ndj=)HOKHgufZ-bnpz+ahaY^ETy%1NQx6sTxXZY5zkme12X_~PQpjH zb~9HNBWFT_P8*;($B`$=&19MDfp;4vN#2}%C87uJ*2iOn4{eWYO%f<~&py4n<0g@R zt$MEK@h*};z2wV8_waG3lcsT{;(p+h;wQkitcS7c0N9=_=SroDi~%c^RgTIuJk~ef zN4{H@?dG)2PAe`MIx*k6D)wT&Q7~|HJ}F#_wcX(x=zV2v;Fi|45nKmE(0YT3{#c3C zCCTEG9)yc6&dE^oi-~o8B!M(}6~!0zTgj4fpck${St9F2Yl53G_pldocl%BG*HJ(H z(@D=N$tSYA$Q7y}QqrJd&dXNf?!Tk3KXK)k9;ca^((I=FTUQnZTY44>z!PC z`GXq1EvD<~lWj+i>^S)}p7zJn?+Sk?NngNem8a2v7&+1W+T-8+GmFPDJTk}nh=Aer5>h;LpU3?q|8UE6D?T zklux;2GQXE@Od>Y=VUIGiUN|-1O1CQeko z>y5G(dWAjLDD1h0;FbmIUo2O1fCs?E$gz?S7T#x9yE}Vvv)#HoeYhsMdfW7E*oKq5 zCyf#V6}u5Gzc6#b3Voy_EXT$BGxuOIurzaJ>6Rtmpye9wC+Z5)+C$*s^BZr2zMqnBl33L})=bOj3!24uRC@(}qYIXAmac2Mu$Fapo%@A+gwELR zGcLe3-$dT%<=_(3o}J_12}4}L`keeB*QAE!o)d z`GxztOZLvb`}FUiBd>CAb1^8au3>CMiv_Ux!S)*R&)eU=_p^6$-#<#jsmYx0d$add zcAQ%DyjZfeuyD>310yf9cLnqJ$3Ua68imOCOzabLs)OB;W$=W9bpY=tA8wcLEs>8I zNJ#?mP9Vd%-0o+&++Uaq6VIs-(~LsSOw0;+_?-1wmZO<_Nj{t|-%FEEgpi^d@8?P-%e!l1fY7>iHhJ%mKJOv+skf-vdLn+(v8~VzbCcWFMzyy=V=|G&UfPnY`Uhs6lJO4rbz3J4z_`Z7LZZHM(yulQnvV0@Cfbw`?03!@d8LATW z4LMw=$A6oZ0VX&`(Al>=b_bIdhgbr*GTE!ruH zPUn|xNU2@ex>Gd2-1HUlaUnWJ=k8j9LZPM+b3JO*7l>6KiEEW@#8!_ z+}a&HlpkN#oeB?Xnv+_boJrwIP|QAMrxhn;Bc)<0{Vr)RZaJxiiTGHMh;2A*`9}R3 zAj1rB5m3eqQB|rY0X7O?{tX;vn`00%0Wbc65I+6C0qK81_6Yp=bbzaUeaeJIt=mPx z{``t{spC76X9P@I1h@(I7vvNh+?u!G<7ttBj)n>Yt)PpHj45)EQ}EH04_HMo(8)>v z0<8JCruH8|(hUmeYM_fd+?u)i2o=VRr;)LB44N4$PjC_cKr?0SvA+*J3eX}2bSVlz zGc${mvKT<~{snA$w-rYFlpg4Es>k^kL|*h(2(EI-;i8137RvukBu>8e6H4qNCiXt< zWS{Pf-trz&ZT%12|CxV*wkVIQpdSdKE!VCRFa8BGn&Qa)#lOJ&+xk|1W=(ki>o21) z^oQ)P(hz;2HOE>DXCIjf+OqcSzi{^2m7Zt*_etyH#4^qN0e!}@o$&)?kjK54GfJa> zA#2Wc-&o7LLc#ZvoI;3?w;yI*36K35To;ZVq%8>n(a1@;@8G+HAG${Ra*?DPy=T zwhtAVX`|&OaMj6x_YV90&?E0j8$`^w9r6ugIwN0|uXmAH`Bic|72ZP3d57jF_xSP9 z0_v4gIwXO8?q1aM4jZ!2@-z37xK{BX3cz}_k{g_&SnL3}ttescCS|_3Rgi%Y>tnk| ze(3&te=;Cy`(X!%({m?kVT>P)VfP9b2(n zz6STEp=lXtR>~U+eC5X?#)BFk5dP%TaEFmpnIsyo#4=OX3(c0*ip1kjOu7I*L@y#a zk{m4mIqPe(hAbs<ny!@L7w--OK-|Q zG;((u&Ht5KDgh~9RXhKtV8q^stFi$pqe+qEq9t4=A+AEuf^-6D>;LEXE2sM{EF7Ef z*`X~SUS99lT2wPcw_IB?l>9yoKhzAd{xIE_{h(jQe(+U($oIk%!^$50p@J?a)kDWD zt{prpoh~C|%SSJonB7Q^{U5)EzW4vs8o_-y-HkwhwdPbk{+owQLkJJK(B<^?=+(e@15Dsc?ZPLW>Zae0qiXs5n;0d!K|);!AtxJupX2+csxIPEVEIX}l_ zS7P>jWs4Xp&w-btLa=hp&(i#6_#!p~$smZmDMWB9nIOh4y#}Nau3yLH?;8AfzZRhdtP@coZH60 z!OoEZ|2|!hmw&T!#@4MP^2h#XL>?nzWbrO$z((%m%Yg^KSU%u)*;;;wxv&;R)|T7^ z+Y|5Ld-jAceard;`Arz7tcJC~FMMC&B1SDoUv0Kuu5+uDzMi$d@}F2+3VVf%D#7xz zP+Hb9-?qleq$1gT!J1Q-$s(UFIEUSH3nGTlqD}G6XV{T=H&@-dlo1`1 z%l^{{uFvZ%$SNahU>c=q*rbVc2mMue8iVY5bPzinc{?_Uqt#+E6JG2hNT?+3R+`z! z7C|$j5Ce3z1Wxhyg_qD~&!b%_=4IBEht2pxcW_ZkS9>4rN8@)^MRhnZmCaw^Abd zw9z!}hu+_Zp9=fF_jlpX@Y%=YKM;3E9M}WgHhP!OwsJ?L_;Gipog>m3+^UIm^e~UN*Ket$paC=+D-bXCqY)da1$=4ijErN*@B(Mz~-A z0;Zm*HL{G1X>Xe2PZ>FRB?Ng@oF_B`5^ zJBD*-U0HG1@-aqiQ@YywXjlJQ-BomzN1j7h`;<11;xOy#Q5?4XipKfMGWS0^u7bm? zF~ea%>;w5A#+}MZaO5rT_QEaZgeKhji{&JZQ&r=a13kY`>o4aldRnG>KqdZhu8w_(i@Lmhp$;1RF%@_i7tpij@0M-(Wbl-ir?iH>-cgkGsr(+6 za8fR&i;(|8;$~WM9~Dsj)kJBW(>i1R1&5rBJOjjSfmCwNYTrnbv`pI#x$mD{0;gR)%dMiQZbLGDU8 zzZoP+u>+6aiG=#|JJx83)49iHXUCFODow6PkL*2i$OI?zeQpIUA4loc$6XJ;!t(_d z8kshoqk|v7k8lLG_7t{uIie;cvO(E18~i*08_yot+?5N+b(#(=>A?2i?Ab8o*xS~v zYJ?oOUKDUSheA@T#Qne~{jbu{C~#-3Atwd!pLX9aU36ijqlXXa_wKp(HS$kVL3VYA ztEY&Z8TnjLAM>w1epV3r!>gx1HXz~y$ffSKJfEOJ405p@E3O5}nw~%Rz5D_@>TW;~E zTa)ZRk~ftP*OCx#`NAKAZVxsDmfqQz=AsWvAoWCwe#^W{8%EyL8O>jkylWZG!U4Z7 zBHwO3Pt5~@=T{&)?I*`6i#0A?gm}$cdh$MrB*Vx2ec#oCdqS@>&!rnOWJ@Xt|8S&$ z^bxK@)y70xipLKmo{$bC$59g|-)cp+y z-uaT)Im(|*Z`}4$8j*?`iRd|XLr7v!V({h>aYG8-$X8pwMZ9h6uRG>J1?yc7v$y=q zFQl`T7rv2W6M|L^LM8U4JDia{m!BWphzklG1k5hsfBBiZmX}15-P3n>yzx8Fe|CW!MSk;<>vm5Ej5v6yO-6kyHV|Ie~?A;iRCNXL>mYAr~SYy&_K1c^{eX2|19?F74~};yP5T+&uO18tDk90s-GsIZHeCeu&>VrHv04AOk#!> z>{j{Oa;66I0sin2Sp~z%52nX!*REw-d_+h&ewJr)F`DA55C)N|S{*l$bA7BP5RoY$ z2Tv`g0JK1;h~?U9gWP>jE)`O>@$RYZKb!5C+inT#GrTjqZYHC@{+srUB;K|5RyN7( zKhM=EJ#QG$8}HR@fMBJcJfRO=KpVh+j+jl552cG607A_EVqYQ;NB`{p5`kFZVR>xR z5G@Mk@g|VHvc&#)mv|V5JQ>$H$qc}Zs>#X5abv8cgW3Q-A&43Rsc>S$b)X0+q%(qa zfs!#$)E~(qVf|)Q-%$Hl^;^ixdfnagA^XwsX7wXvef4P~@wGpi%gnd?hs~#UeM9G( zZ>PgOAuV2S^2M<6=C{W~$P+};FUWh1w za$Jf7ptm<5PdE}G8VfaoFo|@JsLLKi$%5@jHg_Q~2Y(%h)dZ7Dk?RoRUF6C3GqJus zD`MY}m@vOQnV2egB2bF7fRv{b#3VY zsHLb9f&{EOSa3S9leRVv!wWO}J4_w8;(0&qF7Nf)_1?={lJ;-A6*uVEfjuiEt-aY1 zEonx@q?mS{3H5v9Ba+##m(pcpmmzB*aiP@rwLcZvb+U|yBBOHYIfjKF-zBacg6h`_ zf{P&_{-O<;5y2J`FIK@!yLz&leZCC;vKI;NF&ZM+NFkTLGq0xY%sXh8ceK6vAZ?B! zOHgD36v}s>c7$AFNU=b7bl8G zziIG8gOLrcHe_{4pTr*$Mkf4_K$L=e z;_zy=HNIf4cI+8B_R!*Of_P$S-KNvoAKE!HY7=j|!eiN!xkGkzRg1RnGtZ7G>)ee! zWR3~zY`PcC-jyobF8fSq5k9>4bd9|rw@B(Z+WXzNoqUC`kl+Nh94Z}F)6dzVuUr4Z z4weaG|DhsXIC9Dgs-fEwp6NZFR-Rn`ClG^so*R=;u--IM5Jv#3bQCpB^X?;vUjbTb z-U`u_*-;eM&F@>cd!8UJE@6d(odQWMLm(2#VFPa|HIR9hQ@+eJMgc(pv6x|M>}?wU zW(C}^b{;9l0dA<{Ul1@v#$8XV@8+6yar%l12ang2BV4t%_IpaYO{kXFa*8Z?OLKob zz}^X^8i%xrlGrArJ>A3(3?@12&c7|D;_2mou%p|+*miUpwTMPOt|Q3HjpHNE6Fqw& zykFdB?A4jMbUS!xGM1YQCW$9TGf=@2Ql_1b&wb=g*6KKr33r5}{sj7ONw3FR1PCYW z&38Jnn={w@uJYLCyDo|fhu;R=uCd16X|M0mt!yp{vu7^uJQlH>XEGU?N^8jC(2bS6XCHH4k& zKb#$PF`BUV9mbNHr7S6L&`U+Q;ssE=1|C!k0V)vG0@NAtM-*t3L72~k#q7w&L7^wp zE5k@C2_VirNSo02-seJxG+SiXWQRato_!fi1s3a%Menkum3kKBzfJTGHz5S znWQ#}Y!TDMme$OtLhU-a#Mj`fZ-DWJ{a)F7)QS>G(N9`6KjLMUzKGpg#4^LhNt()u z*lC1J({>^A_3+mi9heTq*$O*?mqR9w6z2 zonceFZ|*2$+V*6V>k9U$tFTIZOggs#aNMeG0cMLUZMqhTK83TxB>D<~of?1>)vBdrUhFZ(L$|LvG5u-RAseBM35En(xAT2MOGZv#LFw^w zB4n-VGi-NvVN%gTd*2abq;G6be4a#Ors!t&+ZHrrhO-2BktB&kg(MUB!B}o!P|iXm z<35C1H_S(zJ-7gi#R9hLukd4kq0`2bfWtwe;TpE;xCEYR;7*J$d#H~gk#{1AmylPR z-MQMb#inD0{dPo{SJGai*vX2UfO2mab^}}G6U>-N7!?J7Ul0CP1;532A^7&H0wH@@ zb98fI(3V{cWVZs(hM#dd8~)`eVtP)ToL$% zW_$6P%1(WaYe^9#{i(4QtcTV3uIc?V0}lJ`kG|C8-su5{{0>M*#_Z}}v~&)8IC^LQ z!HZ`zhz*-@R4#-6w>M0Daa@StVYt!ORKYk3#>QfH3t(b5qEX=fVNo(P?Pbz;jNgW|jryX)SoiQ5P3;S);M=qrY z+t+Dg2hfpV|4g4_@&>a5H?*2sC&X8eOKvCI3c8-{`;Q=g*|a$+93f8a!7kU*2f7l^ z;1;HdIXfvr>T*`kO{44qA>gP-LC(hBl6^41;o)6b)V=?jZi*p$*gyZG4)~U1@ez`rW>& z-%_BU>(j3PaN?(Nt&cpyU63|pO3zRF{sSG=oz@N^K|T>WJD!#x#n6P161L>VqC?kQ3`U8hA`v(4fs;{{>D%T=SkfEuSi@_Vm|F?TEjNsS;lbIi*A~nJb$Z*Uz6uKr#uP(S%Rcsh1B43*awdyE@(Jhmb=J8&P zR2EO0@Q~WZaI7A4+p4zC#Yy56T-9vh#s`lXMK7#ZEx#-?tq=#KngD^u4aar$Pv8^+xM>X~fDh;Dst#B67;EK|IR&y{+w|Aqv=DAS?PmCXtXW8X)_jk2FUy*& z{aU17EtR_rq{6toF*6C8wi3O6o) zx+zC>Z4gf2I8q^-gzSb~D^`~foJtKk$evgQ2D)k?Tz&hy5of0`Q$m$>ny|;w(;;e zR(gJ-c!P{N2Jj|HT*rRczM9?LOzqhb0m&$54;foBgV1J;>L+1$rre8H8u~#XAQ}&U zgW4ZnL|m4X>Wbh@I-{ij&`dGu1iRjB5WKudXg~Hmm)$axd#{M(?7@Bv9!L^Qt#1xp z>g?3H%X<>XuDgyI<4T$zH9v*&?AHtI`iQg;d8^;uDd^kw5h{q4hh zw#v=TqJcH)g*)roC8lQ=bflr)nC{XdPU>h4nJVb;!|c@a!eZ*(uV=p^(u8G@UH!}t0I$f`^h;sB z_zX2TC}<2Y1@KOT=r99SRUo!p(L5?)LjIE42TSwEvw`DMXQxipkU8Q_c94?(Y!N!K zi1b6R_9#U|^tWfrq|F#u7c?0TX%eIlep*MFf@0 zZ>m$$z?nPYJPDKY+5!e66H4SCpq0pPTSIO13TtMg4iBr}mMbTu z;>N8yj33;-W0UuzX$|U2_SLf$6KaMuB83>Lu{cl-L(&!nDo-zCr?qk!oNmDX!TpSa zVh{)p7Pjp;Gwo7uM~A&c_1TmYg|?#Et#PN4&9~3YEQ_YLv0)=}kl6+b(%B1$$5K(8 z_qL=C`=X~PPY}X{vFr))i>?p4pF&SNq34K0;L3d%9`L$~MnWNKHuVUjLzB$k3pq6N zefldh66<-Hut*+>`ym74)aM7<1j16m-RYp>R@{`}waBk=9gaFm2i;BIOLdo$u(<=r zlIx?l-WoEi;rK1T44P%Sv_5!N9?8_4)2#n~hQIJ^-)J<{)ofzN2&UvtZ!FEA7IDgUpJ>s&&4yJmug#N{q zJMP5@m-h(0Ov}vYo9i_ZDf!7ovnX9KiHxrwnH1p=no%~q7(4A$vVhDOQB8QLjTjtmxMsI?-G<$i?pktoxlC<$mh&$=mnvVj zuPq0#(XJ(D5IL<*26TIiR&c#5A^$2J)_XJa_KPIwn{a-s%?9fwv~yF|2(7Ew?DLP z7M^(udCUOUtYy|`5c9(6RwicQLzU;mf4XY%q5AS)T`Ct+{*Ny4<`HQJswz{B=2fZ7 zflh3l64U-^-oMHmYdHWMleU!jCItZoOA6n`LVO1d0ZLb^A}Qi1t=Hu- zAFms%*ZJ=v&OO%O)mJ|Lu2wamP!;0(d~AZtl=44*S7$2s;X8j`vj1?O?SPNhQN9Fk zX8t>{`>V>apYdP6<39d7zt0v_scOe|D91ZB&I~vp%Yb^*K_dqf zgTd2GZtWwEV|40p)`fky(f!LGO*k6Qp7%`Kd(LWG>hwcdP|Hq7d3~EJ+g`jB=1c)R`yCHDs07Hf6=O18i zN9p8h-;frkXvTix)F9SF_WYLZKW!?L7EIb!z3!YcTk3qJtQoKlpXj}Xxn5DTSD|M= zmL*l6xBnGrFU^{Kv!niikJ3r=cJ-jzog;SFup#nZ(&%{Ii=^3pN{((?@kP|P?9g69 zo#!Bt$8hod3jN0OWHi0|eJO1jm6Rb#4OK`JF~2jRyQ#m|CQsu=5$O9zU9;26NowobLCOKRKC`JZ%2g8R}x7Vh|& zjQAu)QoqcPDUy8FnP-aPovo-R3x_TZv~hl@2Nnaxt%|P>MOnywtYoT#RRL}Sq8oeI zX88O$*G8*>o)}4n5SM#Ia%8{J+TGeL`YK&*_wDM*!El0DMrPNiWa3|?ne97}=43k5 zfG?hr?n4?==||Rn0%K~q&k0oB9IG`RYXAoYf7p-+&I-_pb!Weu|GY=?_YJZbyJsfbMkTFz;D5*42Fm)XpB`UYe<5sNm)buS`aQ_4IxjQ z7ScT?W-!r`Uk?xmWjXa^-7m9`zX|wi}oG zdK8klP_>O(cV}oK@%IUikvd zMhclX*?01EN>ZtY)QxG`@B|3*+(vDiSj)Fz1MoeFLpEa+eiaO3Tbim+)mt?P)Zy_W zXf9ud|F8+8vfe&)7NIk2M;|`n1~47@(h}{xyX;plVWKvHbc%3N>we1Ax{jO$0&ZDq-lN{Vz+c;h z?X0bK9X7j@)@59=K*ux^N~%e6r1@7VqD|w)-qQI!^EO3)OPYR8E7-|15$qrvA^8F+ z*>W@V5ptuZQ9?$OoMU%nb3oD2UV@09{<>v&0yGu;Ca_KH?5R`)JtU56bV7my^V})E zQ>RkmKW!0ID6sJyYEZU94XoCQ6V|b(;#l9t4OiEzD-(~I*k-t>=F3Gjh=PN$kwDB7 z;IBh?1j8UYct}F${t z>A-n^69(%YCymI*Z zmZ{A7t*rQbVGVG4>M(<$zd*Db=fjxB3N?{Wo9=T^`|JLgf#JsB7M&ey z9lk`}esdPriRboVr_%o9klqZ_td{C`F=liKw| zjLm=V6V@n|h z;t{<+k08M%tZx{#TQs8Q!3g%l0qW0ah6u*tC%f&2H6oSJ{tNeycd_?zChf0^y7Uqs_wJp_kq|8*-o((xM-O0 zMyR6UBB?oFlRmF`zg=bPcC#($0Sh2^KtyD}6u6`=DR3E48ca%<)gddqe9l5%{!Sy< z!%@T&ieIfc4uM!u(6YW{KP=%07ZvjnreyVd{fZ5k~5n1-3A=Lwa<_vk)^R{CAleHvmwP`K%e z`SdCB_gQ(msg_C35ylF$z~E3Gytk&Sf~96$-jhO>ow=oI_^b3-UW_0m$nC-5-VqLEQEB6Zg3*Y1mbB6I#;q^2`V0 zW#gpH%(l|VeB_+G$`*N`6oEi{SANeYfTTlsJ8yt$)fW$mABk9Wuj$!Uq=r16Nc+D6 zwNByQHP(A|P%&yy%X-VIFCMU8*bj@sq?2b?vAgdkv&#J_7m62p3E~)7SQG*7ARh#g zz?-oLnYt{qE88K|T=?51Hs%-+OfPVMZOb2YHcmjCd(5 zf0A4d&iZQdyoC-neu>1bCmXj+JjUK^?i*i-Z0zwyb?u z^Ur(4b_*YYQpX9ctcLbnL3`TC8vYcwyje-*|C;&@IL2$;=W@3z%a=8kfkXx4){Uc! z#DS=b!7VrsCqK+n17AXVqXef-0_6D<=JT{6`|Bu~xA*3Bv%Xa7`Tiw|YSVof>pFz^ zv5_Ah#^C(t!({OZHs@at3u{dKKYbW$#|gdU8zu5wwdbP2ddnWwNr(pPE#oaqIMY%& zRxvHyDcGZp!K#ez|NBn+Dz;@tne9*}9}{lh6R`7YWCeIr2dNk!Yh7#>57VX7K4GS! z+3mC^Y*!8l=uY&*T6qYohc6*4?8GA+sdyp}dzOLO<6MU^1+}-JHf^hrt1b7a5De;qXp&F{0rTsX2#xPk2zsJw2W z@O{xd^Ir{{MrlIpkD|g@vbN^@_7z7zuLTIOB(mVR9igEsh)HtGIl4pR;{T)`xYH`j zVBwI|1Tr2!m*6+ zjN4%KgBFqfWSrn>{?WVzjss2iu>RQc#&1H%BMK9+8;nFHyf9@eMdXBleG7&8)3Sq) z3)#c^Jx@+CvWM^!^Il*iiKGwh#U>%+UsJMcFgq=)Ovf6KM69?wXcs}du;P$z9St&K z#rmsp8b8BZWP0H*^faf2i+U`4-jw5liM~FJ2Y+UVl|1eL`QT70^Xko;K1s{Y>;0IH zJ=OjnAYYdn z&P~E|>NYM4DY($LYuTvG+K%=P?n4f|U7o%&)%mg6sriJsGWY2E4XSrv)T@!Bqbxbp zh|3~nIH&6VK$Z*&5%N7eon=B=Pui5# zxo+=notlIyW7tf-2U_vS01c?k+iWmuaX`~ROtGi_8d|)U)*#bawTBf=+lJIOjIYsZ zuKCK>r}L6As!~PeebMKAt&=}e>iU<9u$+8FXI9=2Tbb*yDJYhz)_^g5hfiwGa|s56 z;6G|2?~tO0G%>wqf57KEd<}77MQ9>P_;fD>N z#4G%op$oAR8MZWEoGO9cXpD{Jv{jS7f}{zo?&|B(Btju-{>46B%SQi0)QnZBj*m&E zM-&L!?Gu8=&lxJFde#hd2TiMirlECe*QBIg;nWp7I(3@IEGMlrB?0bUPBQ(3npA=z zSOw-Q{)7_+cd7IED0v$KV08tE n|4L0aL6kWhzBWv@3uDNxp-JDIQyu2H@B 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