@synnaxlabs/client 0.53.1 → 0.54.0

package/dist/src/arc/types.gen.d.ts

@@ -0,0 +1,2394 @@
+import { status } from '@synnaxlabs/x';
+import { z } from 'zod';
+import { ontology } from '../ontology';
+export declare const MODES: readonly ["text", "graph"];
+export declare const modeZ: z.ZodEnum<{
+    text: "text";
+    graph: "graph";
+}>;
+export type Mode = z.infer<typeof modeZ>;
+/** StatusDetails contains Arc-specific status details for execution state. */
+export declare const statusDetailsZ: z.ZodObject<{
+    running: z.ZodBoolean;
+}, z.core.$strip>;
+export interface StatusDetails extends z.infer<typeof statusDetailsZ> {
+}
+export declare const keyZ: z.ZodUUID;
+export type Key = z.infer<typeof keyZ>;
+export declare const statusZ: status.StatusZodObject<z.ZodObject<{
+    running: z.ZodBoolean;
+}, z.core.$strip>, z.ZodEnum<{
+    success: "success";
+    error: "error";
+    info: "info";
+    warning: "warning";
+    loading: "loading";
+    disabled: "disabled";
+}>>;
+export type Status = z.infer<typeof statusZ>;
+/** New contains parameters for creating a new Arc module. */
+export declare const newZ: z.ZodObject<{
+    key: z.ZodOptional<z.ZodUUID>;
+    name: z.ZodString;
+    mode: z.ZodEnum<{
+        text: "text";
+        graph: "graph";
+    }>;
+    graph: z.ZodObject<{
+        viewport: z.ZodObject<{
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+            zoom: z.ZodNumber;
+        }, z.core.$strip>;
+        functions: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            key: string;
+            body?: {
+                raw: string;
+            } | undefined;
+            config?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            inputs?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            outputs?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            channels?: {
+                read: Record<number, string>;
+                write: Record<number, string>;
+            } | undefined;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            body: z.ZodOptional<z.ZodObject<{
+                raw: z.ZodString;
+            }, z.core.$strip>>;
+            config: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            inputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            outputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            channels: z.ZodOptional<z.ZodObject<{
+                read: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+                write: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>]>;
+        edges: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            source: {
+                node: string;
+                param: string;
+            };
+            target: {
+                node: string;
+                param: string;
+            };
+            kind?: import('./ir/types.gen').EdgeKind | undefined;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            source: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+            target: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+            kind: z.ZodOptional<z.ZodEnum<typeof import('./ir/types.gen').EdgeKind>>;
+        }, z.core.$strip>>]>;
+        nodes: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            key: string;
+            type: string;
+            config: import('@synnaxlabs/x/dist/src/record/record').Unknown;
+            position: {
+                x: number;
+                y: number;
+            };
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodString;
+            config: z.ZodType<import('@synnaxlabs/x/dist/src/record/record').Unknown, unknown, z.core.$ZodTypeInternals<import('@synnaxlabs/x/dist/src/record/record').Unknown, unknown>>;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>]>;
+    }, z.core.$strip>;
+    text: z.ZodObject<{
+        raw: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export interface New extends z.input<typeof newZ> {
+}
+/**
+ * Arc is an Arc module combining visual graph representation and text-based
+ * source code for reactive control systems. Compiles to WebAssembly for
+ * sandboxed execution.
+ */
+export declare const arcZ: z.ZodObject<{
+    key: z.ZodUUID;
+    name: z.ZodString;
+    mode: z.ZodEnum<{
+        text: "text";
+        graph: "graph";
+    }>;
+    graph: z.ZodObject<{
+        viewport: z.ZodObject<{
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+            zoom: z.ZodNumber;
+        }, z.core.$strip>;
+        functions: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            key: string;
+            body?: {
+                raw: string;
+            } | undefined;
+            config?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            inputs?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            outputs?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            channels?: {
+                read: Record<number, string>;
+                write: Record<number, string>;
+            } | undefined;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            body: z.ZodOptional<z.ZodObject<{
+                raw: z.ZodString;
+            }, z.core.$strip>>;
+            config: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            inputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            outputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            channels: z.ZodOptional<z.ZodObject<{
+                read: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+                write: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>]>;
+        edges: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            source: {
+                node: string;
+                param: string;
+            };
+            target: {
+                node: string;
+                param: string;
+            };
+            kind?: import('./ir/types.gen').EdgeKind | undefined;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            source: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+            target: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+            kind: z.ZodOptional<z.ZodEnum<typeof import('./ir/types.gen').EdgeKind>>;
+        }, z.core.$strip>>]>;
+        nodes: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            key: string;
+            type: string;
+            config: import('@synnaxlabs/x/dist/src/record/record').Unknown;
+            position: {
+                x: number;
+                y: number;
+            };
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodString;
+            config: z.ZodType<import('@synnaxlabs/x/dist/src/record/record').Unknown, unknown, z.core.$ZodTypeInternals<import('@synnaxlabs/x/dist/src/record/record').Unknown, unknown>>;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>]>;
+    }, z.core.$strip>;
+    text: z.ZodObject<{
+        raw: z.ZodString;
+    }, z.core.$strip>;
+    program: z.ZodOptional<z.ZodObject<{
+        functions: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            key: string;
+            body?: {
+                raw: string;
+            } | undefined;
+            config?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            inputs?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            outputs?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            channels?: {
+                read: Record<number, string>;
+                write: Record<number, string>;
+            } | undefined;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            body: z.ZodOptional<z.ZodObject<{
+                raw: z.ZodString;
+            }, z.core.$strip>>;
+            config: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            inputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            outputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            channels: z.ZodOptional<z.ZodObject<{
+                read: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+                write: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>]>>;
+        nodes: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            key: string;
+            type: string;
+            config?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            inputs?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            outputs?: {
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[] | undefined;
+            channels?: {
+                read: Record<number, string>;
+                write: Record<number, string>;
+            } | undefined;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodString;
+            config: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            inputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            outputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                name: string;
+                type: {
+                    kind: import('./types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: {
+                        kind: import('./types/types.gen').Kind;
+                        name: string;
+                        inputs?: /*elided*/ any[] | undefined;
+                        outputs?: /*elided*/ any[] | undefined;
+                        config?: /*elided*/ any[] | undefined;
+                        elem?: /*elided*/ any | undefined;
+                        unit?: {
+                            dimensions: {
+                                length: number;
+                                mass: number;
+                                time: number;
+                                current: number;
+                                temperature: number;
+                                angle: number;
+                                count: number;
+                                data: number;
+                            };
+                            scale: number;
+                            name: string;
+                        } | undefined;
+                        constraint?: /*elided*/ any | undefined;
+                        chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                    } | undefined;
+                    chanDirection?: import('./types/types.gen').ChanDirection | undefined;
+                };
+                value?: unknown;
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodObject<{
+                    inputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    outputs: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    config: z.ZodOptional<typeof import('./types/types.gen').paramsZ>;
+                    kind: z.ZodEnum<typeof import('./types/types.gen').Kind>;
+                    name: z.ZodString;
+                    readonly elem: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    unit: z.ZodOptional<z.ZodObject<{
+                        dimensions: z.ZodObject<{
+                            length: z.ZodInt;
+                            mass: z.ZodInt;
+                            time: z.ZodInt;
+                            current: z.ZodInt;
+                            temperature: z.ZodInt;
+                            angle: z.ZodInt;
+                            count: z.ZodInt;
+                            data: z.ZodInt;
+                        }, z.core.$strip>;
+                        scale: z.ZodNumber;
+                        name: z.ZodString;
+                    }, z.core.$strip>>;
+                    readonly constraint: z.ZodOptional<typeof import('./types/types.gen').typeZ>;
+                    chanDirection: z.ZodOptional<z.ZodEnum<typeof import('./types/types.gen').ChanDirection>>;
+                }, z.core.$strip>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>]>>;
+            channels: z.ZodOptional<z.ZodObject<{
+                read: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+                write: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>]>>;
+        edges: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            source: {
+                node: string;
+                param: string;
+            };
+            target: {
+                node: string;
+                param: string;
+            };
+            kind?: import('./ir/types.gen').EdgeKind | undefined;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            source: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+            target: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+            kind: z.ZodOptional<z.ZodEnum<typeof import('./ir/types.gen').EdgeKind>>;
+        }, z.core.$strip>>]>>;
+        strata: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string[][], null | undefined>>, z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string[], null | undefined>>, z.ZodArray<z.ZodString>]>>]>>;
+        sequences: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            key: string;
+            stages: {
+                key: string;
+                nodes: string[];
+                strata: string[][];
+            }[];
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            stages: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+                key: string;
+                nodes: string[];
+                strata: string[][];
+            }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                nodes: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string[], null | undefined>>, z.ZodArray<z.ZodString>]>;
+                strata: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string[][], null | undefined>>, z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string[], null | undefined>>, z.ZodArray<z.ZodString>]>>]>;
+            }, z.core.$strip>>]>;
+        }, z.core.$strip>>]>>;
+        authorities: z.ZodOptional<z.ZodObject<{
+            default: z.ZodOptional<z.ZodInt>;
+            channels: z.ZodOptional<z.ZodRecord<z.ZodUInt32, z.ZodInt>>;
+        }, z.core.$strip>>;
+        wasm: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+        outputMemoryBases: z.ZodRecord<z.ZodString, z.ZodUInt32>;
+    }, z.core.$strip>>;
+    status: z.ZodOptional<status.StatusZodObject<z.ZodObject<{
+        running: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodEnum<{
+        success: "success";
+        error: "error";
+        info: "info";
+        warning: "warning";
+        loading: "loading";
+        disabled: "disabled";
+    }>>>;
+}, z.core.$strip>;
+export interface Arc extends z.infer<typeof arcZ> {
+}
+export declare const ontologyID: ontology.CreateID<string>;
+export declare const TYPE_ONTOLOGY_ID: {
+    type: "arc" | "builtin" | "channel" | "cluster" | "device" | "framer" | "group" | "label" | "lineplot" | "log" | "node" | "policy" | "rack" | "range" | "range-alias" | "role" | "schematic" | "schematic_symbol" | "status" | "table" | "task" | "user" | "view" | "workspace";
+    key: string;
+} | {
+    type: "arc" | "builtin" | "channel" | "cluster" | "device" | "framer" | "group" | "label" | "lineplot" | "log" | "node" | "policy" | "rack" | "range" | "range-alias" | "role" | "schematic" | "schematic_symbol" | "status" | "table" | "task" | "user" | "view" | "workspace";
+    key: string;
+};
+//# sourceMappingURL=types.gen.d.ts.map