@synnaxlabs/client 0.53.1 → 0.54.0

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

@@ -0,0 +1,644 @@
+import { record } from '@synnaxlabs/x';
+import { z } from 'zod';
+import { ir } from '../ir';
+/**
+ * Node is a visual node in the Arc graph editor representing a function
+ * instantiation with position data.
+ */
+export declare const nodeZ: z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodString;
+    config: z.ZodType<record.Unknown, unknown, z.core.$ZodTypeInternals<record.Unknown, unknown>>;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export interface Node extends z.infer<typeof nodeZ> {
+}
+/** Viewport is the camera state for viewing the Arc graph editor canvas. */
+export declare const viewportZ: z.ZodObject<{
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    zoom: z.ZodNumber;
+}, z.core.$strip>;
+export interface Viewport extends z.infer<typeof viewportZ> {
+}
+export declare const nodesZ: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+    key: string;
+    type: string;
+    config: record.Unknown;
+    position: {
+        x: number;
+        y: number;
+    };
+}[], null | undefined>>, z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodString;
+    config: z.ZodType<record.Unknown, unknown, z.core.$ZodTypeInternals<record.Unknown, unknown>>;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>>]>;
+export type Nodes = z.infer<typeof nodesZ>;
+/**
+ * Graph is a visual dataflow graph representation combining IR elements with
+ * canvas layout for the Arc graph editor.
+ */
+export declare const graphZ: z.ZodObject<{
+    viewport: z.ZodObject<{
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        zoom: z.ZodNumber;
+    }, z.core.$strip>;
+    functions: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+        key: string;
+        body?: {
+            raw: string;
+        } | undefined;
+        config?: {
+            name: string;
+            type: {
+                kind: import('../types/types.gen').Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                unit?: {
+                    dimensions: {
+                        length: number;
+                        mass: number;
+                        time: number;
+                        current: number;
+                        temperature: number;
+                        angle: number;
+                        count: number;
+                        data: number;
+                    };
+                    scale: number;
+                    name: string;
+                } | undefined;
+                constraint?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[] | undefined;
+        inputs?: {
+            name: string;
+            type: {
+                kind: import('../types/types.gen').Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                unit?: {
+                    dimensions: {
+                        length: number;
+                        mass: number;
+                        time: number;
+                        current: number;
+                        temperature: number;
+                        angle: number;
+                        count: number;
+                        data: number;
+                    };
+                    scale: number;
+                    name: string;
+                } | undefined;
+                constraint?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[] | undefined;
+        outputs?: {
+            name: string;
+            type: {
+                kind: import('../types/types.gen').Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                unit?: {
+                    dimensions: {
+                        length: number;
+                        mass: number;
+                        time: number;
+                        current: number;
+                        temperature: number;
+                        angle: number;
+                        count: number;
+                        data: number;
+                    };
+                    scale: number;
+                    name: string;
+                } | undefined;
+                constraint?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[] | undefined;
+        channels?: {
+            read: Record<number, string>;
+            write: Record<number, string>;
+        } | undefined;
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        body: z.ZodOptional<z.ZodObject<{
+            raw: z.ZodString;
+        }, z.core.$strip>>;
+        config: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            name: string;
+            type: {
+                kind: import('../types/types.gen').Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                unit?: {
+                    dimensions: {
+                        length: number;
+                        mass: number;
+                        time: number;
+                        current: number;
+                        temperature: number;
+                        angle: number;
+                        count: number;
+                        data: number;
+                    };
+                    scale: number;
+                    name: string;
+                } | undefined;
+                constraint?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodObject<{
+                inputs: z.ZodOptional<typeof import('../types/types.gen').paramsZ>;
+                outputs: z.ZodOptional<typeof import('../types/types.gen').paramsZ>;
+                config: z.ZodOptional<typeof import('../types/types.gen').paramsZ>;
+                kind: z.ZodEnum<typeof import('../types/types.gen').Kind>;
+                name: z.ZodString;
+                readonly elem: z.ZodOptional<typeof import('../types/types.gen').typeZ>;
+                unit: z.ZodOptional<z.ZodObject<{
+                    dimensions: z.ZodObject<{
+                        length: z.ZodInt;
+                        mass: z.ZodInt;
+                        time: z.ZodInt;
+                        current: z.ZodInt;
+                        temperature: z.ZodInt;
+                        angle: z.ZodInt;
+                        count: z.ZodInt;
+                        data: z.ZodInt;
+                    }, z.core.$strip>;
+                    scale: z.ZodNumber;
+                    name: z.ZodString;
+                }, z.core.$strip>>;
+                readonly constraint: z.ZodOptional<typeof import('../types/types.gen').typeZ>;
+                chanDirection: z.ZodOptional<z.ZodEnum<typeof import('../types/types.gen').ChanDirection>>;
+            }, z.core.$strip>;
+            value: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>]>>;
+        inputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            name: string;
+            type: {
+                kind: import('../types/types.gen').Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                unit?: {
+                    dimensions: {
+                        length: number;
+                        mass: number;
+                        time: number;
+                        current: number;
+                        temperature: number;
+                        angle: number;
+                        count: number;
+                        data: number;
+                    };
+                    scale: number;
+                    name: string;
+                } | undefined;
+                constraint?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodObject<{
+                inputs: z.ZodOptional<typeof import('../types/types.gen').paramsZ>;
+                outputs: z.ZodOptional<typeof import('../types/types.gen').paramsZ>;
+                config: z.ZodOptional<typeof import('../types/types.gen').paramsZ>;
+                kind: z.ZodEnum<typeof import('../types/types.gen').Kind>;
+                name: z.ZodString;
+                readonly elem: z.ZodOptional<typeof import('../types/types.gen').typeZ>;
+                unit: z.ZodOptional<z.ZodObject<{
+                    dimensions: z.ZodObject<{
+                        length: z.ZodInt;
+                        mass: z.ZodInt;
+                        time: z.ZodInt;
+                        current: z.ZodInt;
+                        temperature: z.ZodInt;
+                        angle: z.ZodInt;
+                        count: z.ZodInt;
+                        data: z.ZodInt;
+                    }, z.core.$strip>;
+                    scale: z.ZodNumber;
+                    name: z.ZodString;
+                }, z.core.$strip>>;
+                readonly constraint: z.ZodOptional<typeof import('../types/types.gen').typeZ>;
+                chanDirection: z.ZodOptional<z.ZodEnum<typeof import('../types/types.gen').ChanDirection>>;
+            }, z.core.$strip>;
+            value: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>]>>;
+        outputs: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+            name: string;
+            type: {
+                kind: import('../types/types.gen').Kind;
+                name: string;
+                inputs?: /*elided*/ any[] | undefined;
+                outputs?: /*elided*/ any[] | undefined;
+                config?: /*elided*/ any[] | undefined;
+                elem?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                unit?: {
+                    dimensions: {
+                        length: number;
+                        mass: number;
+                        time: number;
+                        current: number;
+                        temperature: number;
+                        angle: number;
+                        count: number;
+                        data: number;
+                    };
+                    scale: number;
+                    name: string;
+                } | undefined;
+                constraint?: {
+                    kind: import('../types/types.gen').Kind;
+                    name: string;
+                    inputs?: /*elided*/ any[] | undefined;
+                    outputs?: /*elided*/ any[] | undefined;
+                    config?: /*elided*/ any[] | undefined;
+                    elem?: /*elided*/ any | undefined;
+                    unit?: {
+                        dimensions: {
+                            length: number;
+                            mass: number;
+                            time: number;
+                            current: number;
+                            temperature: number;
+                            angle: number;
+                            count: number;
+                            data: number;
+                        };
+                        scale: number;
+                        name: string;
+                    } | undefined;
+                    constraint?: /*elided*/ any | undefined;
+                    chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+                } | undefined;
+                chanDirection?: import('../types/types.gen').ChanDirection | undefined;
+            };
+            value?: unknown;
+        }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodObject<{
+                inputs: z.ZodOptional<typeof import('../types/types.gen').paramsZ>;
+                outputs: z.ZodOptional<typeof import('../types/types.gen').paramsZ>;
+                config: z.ZodOptional<typeof import('../types/types.gen').paramsZ>;
+                kind: z.ZodEnum<typeof import('../types/types.gen').Kind>;
+                name: z.ZodString;
+                readonly elem: z.ZodOptional<typeof import('../types/types.gen').typeZ>;
+                unit: z.ZodOptional<z.ZodObject<{
+                    dimensions: z.ZodObject<{
+                        length: z.ZodInt;
+                        mass: z.ZodInt;
+                        time: z.ZodInt;
+                        current: z.ZodInt;
+                        temperature: z.ZodInt;
+                        angle: z.ZodInt;
+                        count: z.ZodInt;
+                        data: z.ZodInt;
+                    }, z.core.$strip>;
+                    scale: z.ZodNumber;
+                    name: z.ZodString;
+                }, z.core.$strip>>;
+                readonly constraint: z.ZodOptional<typeof import('../types/types.gen').typeZ>;
+                chanDirection: z.ZodOptional<z.ZodEnum<typeof import('../types/types.gen').ChanDirection>>;
+            }, z.core.$strip>;
+            value: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>]>>;
+        channels: z.ZodOptional<z.ZodObject<{
+            read: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+            write: z.ZodRecord<z.ZodUInt32, z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>;
+    edges: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+        source: {
+            node: string;
+            param: string;
+        };
+        target: {
+            node: string;
+            param: string;
+        };
+        kind?: ir.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 ir.EdgeKind>>;
+    }, z.core.$strip>>]>;
+    nodes: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>, z.ZodTransform<{
+        key: string;
+        type: string;
+        config: record.Unknown;
+        position: {
+            x: number;
+            y: number;
+        };
+    }[], null | undefined>>, z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        type: z.ZodString;
+        config: z.ZodType<record.Unknown, unknown, z.core.$ZodTypeInternals<record.Unknown, unknown>>;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>]>;
+}, z.core.$strip>;
+export interface Graph extends z.infer<typeof graphZ> {
+}
+//# sourceMappingURL=types.gen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.gen.d.ts","sourceRoot":"","sources":["../../../../src/arc/graph/types.gen.ts"],"names":[],"mappings":"AAWA,OAAO,EAAS,MAAM,EAAW,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAE9B;;;GAGG;AACH,eAAO,MAAM,KAAK;;;;;;;;iBAShB,CAAC;AACH,MAAM,WAAW,IAAK,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC;CAAG;AAEtD,4EAA4E;AAC5E,eAAO,MAAM,SAAS;;;;;;iBAKpB,CAAC;AACH,MAAM,WAAW,QAAS,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC;CAAG;AAE9D,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;oBAA8B,CAAC;AAClD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASjB,CAAC;AACH,MAAM,WAAW,KAAM,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC;CAAG"}

package/dist/src/arc/ir/index.d.ts

@@ -0,0 +1,2 @@
+export * as ir from './types.gen';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/arc/ir/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/arc/ir/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAC"}