@synnaxlabs/client 0.53.0 → 0.54.0

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

@@ -0,0 +1,2988 @@
+import { z } from 'zod';
+import { types } from '../types';
+export declare enum EdgeKind {
+    unspecified = 0,
+    continuous = 1,
+    one_shot = 2
+}
+export declare const edgeKindZ: z.ZodEnum<typeof EdgeKind>;
+/** Handle is a reference to a specific parameter on a specific node in the dataflow graph. */
+export declare const handleZ: z.ZodObject<{
+    node: z.ZodString;
+    param: z.ZodString;
+}, z.core.$strip>;
+export interface Handle extends z.infer<typeof handleZ> {
+}
+/** Body is raw function body source code with optional parsed AST. */
+export declare const bodyZ: z.ZodObject<{
+    raw: z.ZodString;
+}, z.core.$strip>;
+export interface Body extends z.infer<typeof bodyZ> {
+}
+/**
+ * Node is a concrete instantiation of a function with typed parameters and
+ * configuration values.
+ */
+export declare const nodeZ: 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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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>;
+export interface Node extends z.infer<typeof nodeZ> {
+}
+/** Authorities holds the static authority declarations from an Arc program. */
+export declare const authoritiesZ: z.ZodObject<{
+    default: z.ZodOptional<z.ZodInt>;
+    channels: z.ZodOptional<z.ZodRecord<z.ZodUInt32, z.ZodInt>>;
+}, z.core.$strip>;
+export interface Authorities extends z.infer<typeof authoritiesZ> {
+}
+export declare const stratumZ: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string[], null | undefined>>, z.ZodArray<z.ZodString>]>;
+export type Stratum = z.infer<typeof stratumZ>;
+/** Edge is a dataflow connection between node parameters in the Arc graph. */
+export declare const edgeZ: 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 EdgeKind>>;
+}, z.core.$strip>;
+export interface Edge extends z.infer<typeof edgeZ> {
+}
+/**
+ * Function is a function template definition with typed parameters, serving as a
+ * blueprint for node instantiation.
+ */
+export declare const functionZ: 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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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>;
+export interface Function extends z.infer<typeof functionZ> {
+}
+export declare const nodesZ: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+    key: string;
+    type: string;
+    config?: {
+        name: string;
+        type: {
+            kind: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[] | undefined;
+    inputs?: {
+        name: string;
+        type: {
+            kind: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[] | undefined;
+    outputs?: {
+        name: string;
+        type: {
+            kind: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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>>]>;
+export type Nodes = z.infer<typeof nodesZ>;
+export declare const strataZ: 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>]>>]>;
+export type Strata = z.infer<typeof strataZ>;
+export declare const edgesZ: 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?: 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 EdgeKind>>;
+}, z.core.$strip>>]>;
+export type Edges = z.infer<typeof edgesZ>;
+export declare const functionsZ: 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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[] | undefined;
+    inputs?: {
+        name: string;
+        type: {
+            kind: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[] | undefined;
+    outputs?: {
+        name: string;
+        type: {
+            kind: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+            name: string;
+            inputs?: /*elided*/ any[] | undefined;
+            outputs?: /*elided*/ any[] | undefined;
+            config?: /*elided*/ any[] | undefined;
+            elem?: {
+                kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+            } | undefined;
+            chanDirection?: types.ChanDirection | undefined;
+        };
+        value?: unknown;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodObject<{
+            inputs: z.ZodOptional<typeof types.paramsZ>;
+            outputs: z.ZodOptional<typeof types.paramsZ>;
+            config: z.ZodOptional<typeof types.paramsZ>;
+            kind: z.ZodEnum<typeof types.Kind>;
+            name: z.ZodString;
+            readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+            chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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>>]>;
+export type Functions = z.infer<typeof functionsZ>;
+/**
+ * Stage is a stage in a sequence state machine, containing active nodes and their
+ * execution stratification.
+ */
+export declare const stageZ: 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>;
+export interface Stage extends z.infer<typeof stageZ> {
+}
+/**
+ * Sequence is a state machine defining ordered stages of execution, where entry point
+ * is always the first stage.
+ */
+export declare const sequenceZ: 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>;
+export interface Sequence extends z.infer<typeof sequenceZ> {
+}
+export declare const stagesZ: 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>>]>;
+export type Stages = z.infer<typeof stagesZ>;
+export declare const sequencesZ: 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>>]>;
+export type Sequences = z.infer<typeof sequencesZ>;
+/**
+ * IR is the intermediate representation of an Arc program as a dataflow graph
+ * with stratified execution, bridging semantic analysis and WebAssembly
+ * compilation.
+ */
+export declare const irZ: 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: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[] | undefined;
+        inputs?: {
+            name: string;
+            type: {
+                kind: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[] | undefined;
+        outputs?: {
+            name: string;
+            type: {
+                kind: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.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: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodObject<{
+                inputs: z.ZodOptional<typeof types.paramsZ>;
+                outputs: z.ZodOptional<typeof types.paramsZ>;
+                config: z.ZodOptional<typeof types.paramsZ>;
+                kind: z.ZodEnum<typeof types.Kind>;
+                name: z.ZodString;
+                readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+                chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodObject<{
+                inputs: z.ZodOptional<typeof types.paramsZ>;
+                outputs: z.ZodOptional<typeof types.paramsZ>;
+                config: z.ZodOptional<typeof types.paramsZ>;
+                kind: z.ZodEnum<typeof types.Kind>;
+                name: z.ZodString;
+                readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+                chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodObject<{
+                inputs: z.ZodOptional<typeof types.paramsZ>;
+                outputs: z.ZodOptional<typeof types.paramsZ>;
+                config: z.ZodOptional<typeof types.paramsZ>;
+                kind: z.ZodEnum<typeof types.Kind>;
+                name: z.ZodString;
+                readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+                chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[] | undefined;
+        inputs?: {
+            name: string;
+            type: {
+                kind: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[] | undefined;
+        outputs?: {
+            name: string;
+            type: {
+                kind: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.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: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodObject<{
+                inputs: z.ZodOptional<typeof types.paramsZ>;
+                outputs: z.ZodOptional<typeof types.paramsZ>;
+                config: z.ZodOptional<typeof types.paramsZ>;
+                kind: z.ZodEnum<typeof types.Kind>;
+                name: z.ZodString;
+                readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+                chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodObject<{
+                inputs: z.ZodOptional<typeof types.paramsZ>;
+                outputs: z.ZodOptional<typeof types.paramsZ>;
+                config: z.ZodOptional<typeof types.paramsZ>;
+                kind: z.ZodEnum<typeof types.Kind>;
+                name: z.ZodString;
+                readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+                chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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: types.Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: types.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?: types.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: types.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?: types.ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: types.ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodObject<{
+                inputs: z.ZodOptional<typeof types.paramsZ>;
+                outputs: z.ZodOptional<typeof types.paramsZ>;
+                config: z.ZodOptional<typeof types.paramsZ>;
+                kind: z.ZodEnum<typeof types.Kind>;
+                name: z.ZodString;
+                readonly elem: z.ZodOptional<typeof types.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 types.typeZ>;
+                chanDirection: z.ZodOptional<z.ZodEnum<typeof types.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?: 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 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>>;
+}, z.core.$strip>;
+export interface IR extends z.infer<typeof irZ> {
+}
+//# sourceMappingURL=types.gen.d.ts.map