@synnaxlabs/client 0.56.1 → 0.57.0

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

@@ -0,0 +1,1439 @@
+import { Draft } from 'immer';
+import { z } from 'zod';
+import { actions } from '../actions';
+import { ir } from './ir';
+import { Arc } from './types.gen';
+/**
+ * Create replaces the document with the given created state. Emitted by the Core on
+ * create so remote caches ingest new documents; clients never dispatch it.
+ */
+export declare const createPayloadZ: z.ZodObject<{
+    arc: z.ZodObject<{
+        key: z.ZodDefault<z.ZodUUID>;
+        name: z.ZodString;
+        mode: z.ZodEnum<{
+            text: "text";
+            graph: "graph";
+        }>;
+        graph: z.ZodPrefault<z.ZodObject<{
+            functions: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                body: z.ZodObject<{
+                    raw: z.ZodString;
+                }, z.core.$strip>;
+                inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                channels: z.ZodObject<{
+                    read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                    write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>>>;
+            edges: z.ZodDefault<z.ZodDefault<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.ZodEnum<typeof ir.EdgeKind>;
+                key: z.ZodString;
+            }, z.core.$strip>>>>;
+            nodes: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                position: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>>>;
+            inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        text: z.ZodPrefault<z.ZodObject<{
+            doc: z.ZodPrefault<z.ZodObject<{
+                inserts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodObject<{
+                        replica: z.ZodUInt32;
+                        counter: z.ZodUInt32;
+                    }, z.core.$strip>;
+                    origin: z.ZodObject<{
+                        replica: z.ZodUInt32;
+                        counter: z.ZodUInt32;
+                    }, z.core.$strip>;
+                    side: z.ZodEnum<{
+                        left: "left";
+                        right: "right";
+                    }>;
+                    char: z.ZodInt32;
+                }, z.core.$strip>>>;
+                deletes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodObject<{
+                        replica: z.ZodUInt32;
+                        counter: z.ZodUInt32;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            raw: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+        program: z.ZodOptional<z.ZodObject<{
+            functions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                body: z.ZodObject<{
+                    raw: z.ZodString;
+                }, z.core.$strip>;
+                inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                channels: z.ZodObject<{
+                    read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                    write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>>;
+            nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                type: z.ZodString;
+                inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                channels: z.ZodObject<{
+                    read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                    write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>>;
+            edges: z.ZodDefault<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.ZodEnum<typeof ir.EdgeKind>;
+            }, z.core.$strip>>>;
+            authorities: z.ZodObject<{
+                default: z.ZodOptional<z.ZodInt>;
+                channels: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodInt>>;
+            }, z.core.$strip>;
+            root: z.ZodType<ir.Scope, unknown, z.core.$ZodTypeInternals<ir.Scope, unknown>>;
+            wasm: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            outputMemoryBases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUInt32>>;
+        }, z.core.$strip>>;
+        status: z.ZodOptional<import('..').StatusZodObject<z.ZodObject<{
+            running: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodEnum<{
+            error: "error";
+            success: "success";
+            info: "info";
+            warning: "warning";
+            loading: "loading";
+            disabled: "disabled";
+        }>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CreatePayload = z.infer<typeof createPayloadZ>;
+/** Rename renames the Arc module. */
+export declare const renamePayloadZ: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+export type RenamePayload = z.infer<typeof renamePayloadZ>;
+/**
+ * SetNode inserts the node if no node with the same key exists, otherwise replaces the
+ * existing node in place. Operates only on the node's position; the node's function
+ * type and inputs are set separately via SetNodeInputs.
+ */
+export declare const setNodePayloadZ: z.ZodObject<{
+    node: z.ZodObject<{
+        key: z.ZodString;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SetNodePayload = z.infer<typeof setNodePayloadZ>;
+/** SetNodePosition moves a graph node to a new canvas position. */
+export declare const setNodePositionPayloadZ: z.ZodObject<{
+    key: z.ZodString;
+    position: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SetNodePositionPayload = z.infer<typeof setNodePositionPayloadZ>;
+/**
+ * SetNodeInputs merges the given inputs into the entry for the given key in the graph
+ * inputs map. Top-level fields present in the payload overwrite existing fields; fields
+ * absent from the payload are preserved. The node's function type is held under "type".
+ */
+export declare const setNodeInputsPayloadZ: z.ZodObject<{
+    key: z.ZodString;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type SetNodeInputsPayload = z.infer<typeof setNodeInputsPayloadZ>;
+/**
+ * RemoveNode removes the node with the given key along with its inputs entry and any
+ * edges connected to it.
+ */
+export declare const removeNodePayloadZ: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$strip>;
+export type RemoveNodePayload = z.infer<typeof removeNodePayloadZ>;
+/**
+ * AddEdge appends the edge to the graph. No-op when an edge with the same source and
+ * target handles already exists, so concurrent additions of the same connection
+ * converge regardless of differing keys.
+ */
+export declare const addEdgePayloadZ: z.ZodObject<{
+    edge: 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.ZodEnum<typeof ir.EdgeKind>;
+        key: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AddEdgePayload = z.infer<typeof addEdgePayloadZ>;
+/** RemoveEdge removes the edge with the given key, if present. */
+export declare const removeEdgePayloadZ: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$strip>;
+export type RemoveEdgePayload = z.infer<typeof removeEdgePayloadZ>;
+/**
+ * ReconnectEdge rewrites the endpoints of the edge with the given key, preserving its
+ * key and kind. No-op when no edge with the key exists.
+ */
+export declare const reconnectEdgePayloadZ: z.ZodObject<{
+    key: z.ZodString;
+    source: z.ZodObject<{
+        node: z.ZodString;
+        param: z.ZodString;
+    }, z.core.$strip>;
+    target: z.ZodObject<{
+        node: z.ZodString;
+        param: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ReconnectEdgePayload = z.infer<typeof reconnectEdgePayloadZ>;
+/**
+ * InsertChar carries a single collaborative-edit character insertion against the
+ * module's text. The payload is a sequence CRDT operation; the server relays it to the
+ * other editors of the module without interpreting it.
+ */
+export declare const insertCharPayloadZ: z.ZodObject<{
+    id: z.ZodObject<{
+        replica: z.ZodUInt32;
+        counter: z.ZodUInt32;
+    }, z.core.$strip>;
+    origin: z.ZodObject<{
+        replica: z.ZodUInt32;
+        counter: z.ZodUInt32;
+    }, z.core.$strip>;
+    side: z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>;
+    char: z.ZodInt32;
+}, z.core.$strip>;
+export type InsertCharPayload = z.infer<typeof insertCharPayloadZ>;
+/**
+ * DeleteChar carries a single collaborative-edit character deletion against the
+ * module's text. The payload is a sequence CRDT operation; the server relays it to the
+ * other editors of the module without interpreting it.
+ */
+export declare const deleteCharPayloadZ: z.ZodObject<{
+    id: z.ZodObject<{
+        replica: z.ZodUInt32;
+        counter: z.ZodUInt32;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type DeleteCharPayload = z.infer<typeof deleteCharPayloadZ>;
+/**
+ * ForgetChars removes the given already-deleted characters from the module's text
+ * document, dropping both their insert and delete operations from the replicated
+ * op-log. The server emits it after a quiet editing period to reclaim the space held by
+ * tombstoned characters. Because the characters are already deleted, and thus
+ * invisible, applying it never changes the materialized text.
+ */
+export declare const forgetCharsPayloadZ: z.ZodObject<{
+    ids: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        replica: z.ZodUInt32;
+        counter: z.ZodUInt32;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ForgetCharsPayload = z.infer<typeof forgetCharsPayloadZ>;
+export declare const actionZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"create">;
+    create: z.ZodObject<{
+        arc: z.ZodObject<{
+            key: z.ZodDefault<z.ZodUUID>;
+            name: z.ZodString;
+            mode: z.ZodEnum<{
+                text: "text";
+                graph: "graph";
+            }>;
+            graph: z.ZodPrefault<z.ZodObject<{
+                functions: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    body: z.ZodObject<{
+                        raw: z.ZodString;
+                    }, z.core.$strip>;
+                    inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                    outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                    channels: z.ZodObject<{
+                        read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                        write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>>>;
+                edges: z.ZodDefault<z.ZodDefault<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.ZodEnum<typeof ir.EdgeKind>;
+                    key: z.ZodString;
+                }, z.core.$strip>>>>;
+                nodes: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    position: z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>>>;
+                inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodUnknown>>>;
+            }, z.core.$strip>>;
+            text: z.ZodPrefault<z.ZodObject<{
+                doc: z.ZodPrefault<z.ZodObject<{
+                    inserts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        id: z.ZodObject<{
+                            replica: z.ZodUInt32;
+                            counter: z.ZodUInt32;
+                        }, z.core.$strip>;
+                        origin: z.ZodObject<{
+                            replica: z.ZodUInt32;
+                            counter: z.ZodUInt32;
+                        }, z.core.$strip>;
+                        side: z.ZodEnum<{
+                            left: "left";
+                            right: "right";
+                        }>;
+                        char: z.ZodInt32;
+                    }, z.core.$strip>>>;
+                    deletes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        id: z.ZodObject<{
+                            replica: z.ZodUInt32;
+                            counter: z.ZodUInt32;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+                raw: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+            program: z.ZodOptional<z.ZodObject<{
+                functions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    body: z.ZodObject<{
+                        raw: z.ZodString;
+                    }, z.core.$strip>;
+                    inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                    outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                    channels: z.ZodObject<{
+                        read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                        write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>>;
+                nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    type: z.ZodString;
+                    inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                    outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                    channels: z.ZodObject<{
+                        read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                        write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>>;
+                edges: z.ZodDefault<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.ZodEnum<typeof ir.EdgeKind>;
+                }, z.core.$strip>>>;
+                authorities: z.ZodObject<{
+                    default: z.ZodOptional<z.ZodInt>;
+                    channels: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodInt>>;
+                }, z.core.$strip>;
+                root: z.ZodType<ir.Scope, unknown, z.core.$ZodTypeInternals<ir.Scope, unknown>>;
+                wasm: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+                outputMemoryBases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUInt32>>;
+            }, z.core.$strip>>;
+            status: z.ZodOptional<import('..').StatusZodObject<z.ZodObject<{
+                running: z.ZodBoolean;
+            }, z.core.$strip>, z.ZodEnum<{
+                error: "error";
+                success: "success";
+                info: "info";
+                warning: "warning";
+                loading: "loading";
+                disabled: "disabled";
+            }>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"rename">;
+    rename: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"set_node">;
+    setNode: z.ZodObject<{
+        node: z.ZodObject<{
+            key: z.ZodString;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"set_node_position">;
+    setNodePosition: z.ZodObject<{
+        key: z.ZodString;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"set_node_inputs">;
+    setNodeInputs: z.ZodObject<{
+        key: z.ZodString;
+        inputs: z.ZodDefault<z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"remove_node">;
+    removeNode: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"add_edge">;
+    addEdge: z.ZodObject<{
+        edge: 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.ZodEnum<typeof ir.EdgeKind>;
+            key: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"remove_edge">;
+    removeEdge: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reconnect_edge">;
+    reconnectEdge: z.ZodObject<{
+        key: z.ZodString;
+        source: z.ZodObject<{
+            node: z.ZodString;
+            param: z.ZodString;
+        }, z.core.$strip>;
+        target: z.ZodObject<{
+            node: z.ZodString;
+            param: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"insert_char">;
+    insertChar: z.ZodObject<{
+        id: z.ZodObject<{
+            replica: z.ZodUInt32;
+            counter: z.ZodUInt32;
+        }, z.core.$strip>;
+        origin: z.ZodObject<{
+            replica: z.ZodUInt32;
+            counter: z.ZodUInt32;
+        }, z.core.$strip>;
+        side: z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>;
+        char: z.ZodInt32;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"delete_char">;
+    deleteChar: z.ZodObject<{
+        id: z.ZodObject<{
+            replica: z.ZodUInt32;
+            counter: z.ZodUInt32;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"forget_chars">;
+    forgetChars: z.ZodObject<{
+        ids: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            replica: z.ZodUInt32;
+            counter: z.ZodUInt32;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type Action = z.infer<typeof actionZ>;
+export declare const create: (payload: z.input<typeof createPayloadZ>) => Action;
+export declare const rename: (payload: z.input<typeof renamePayloadZ>) => Action;
+export declare const setNode: (payload: z.input<typeof setNodePayloadZ>) => Action;
+export declare const setNodePosition: (payload: z.input<typeof setNodePositionPayloadZ>) => Action;
+export declare const setNodeInputs: (payload: z.input<typeof setNodeInputsPayloadZ>) => Action;
+export declare const removeNode: (payload: z.input<typeof removeNodePayloadZ>) => Action;
+export declare const addEdge: (payload: z.input<typeof addEdgePayloadZ>) => Action;
+export declare const removeEdge: (payload: z.input<typeof removeEdgePayloadZ>) => Action;
+export declare const reconnectEdge: (payload: z.input<typeof reconnectEdgePayloadZ>) => Action;
+export declare const insertChar: (payload: z.input<typeof insertCharPayloadZ>) => Action;
+export declare const deleteChar: (payload: z.input<typeof deleteCharPayloadZ>) => Action;
+export declare const forgetChars: (payload: z.input<typeof forgetCharsPayloadZ>) => Action;
+export type HandlerResult = actions.HandlerResult<Action>;
+export type ReduceAllResult = actions.ReduceAllResult<Arc, Action>;
+export interface Handlers {
+    create: (state: Draft<Arc>, payload: CreatePayload) => HandlerResult;
+    rename: (state: Draft<Arc>, payload: RenamePayload) => HandlerResult;
+    setNode: (state: Draft<Arc>, payload: SetNodePayload) => HandlerResult;
+    setNodePosition: (state: Draft<Arc>, payload: SetNodePositionPayload) => HandlerResult;
+    setNodeInputs: (state: Draft<Arc>, payload: SetNodeInputsPayload) => HandlerResult;
+    removeNode: (state: Draft<Arc>, payload: RemoveNodePayload) => HandlerResult;
+    addEdge: (state: Draft<Arc>, payload: AddEdgePayload) => HandlerResult;
+    removeEdge: (state: Draft<Arc>, payload: RemoveEdgePayload) => HandlerResult;
+    reconnectEdge: (state: Draft<Arc>, payload: ReconnectEdgePayload) => HandlerResult;
+    insertChar: (state: Draft<Arc>, payload: InsertCharPayload) => HandlerResult;
+    deleteChar: (state: Draft<Arc>, payload: DeleteCharPayload) => HandlerResult;
+    forgetChars: (state: Draft<Arc>, payload: ForgetCharsPayload) => HandlerResult;
+}
+export declare const createReduceAll: (handlers: Handlers) => (state: Arc, actions: ({
+    type: "create";
+    create: {
+        arc: {
+            key: string;
+            name: string;
+            mode: "text" | "graph";
+            graph: {
+                functions: {
+                    key: string;
+                    body: {
+                        raw: string;
+                    };
+                    inputs: import('..').Param[];
+                    outputs: import('..').Param[];
+                    channels: {
+                        read: Record<number, string>;
+                        write: Record<number, string>;
+                    };
+                }[];
+                edges: {
+                    source: {
+                        node: string;
+                        param: string;
+                    };
+                    target: {
+                        node: string;
+                        param: string;
+                    };
+                    kind: ir.EdgeKind;
+                    key: string;
+                }[];
+                nodes: {
+                    key: string;
+                    position: {
+                        x: number;
+                        y: number;
+                    };
+                }[];
+                inputs: Record<string, Record<string | number, unknown>>;
+            };
+            text: {
+                doc: {
+                    inserts: {
+                        id: {
+                            replica: number;
+                            counter: number;
+                        };
+                        origin: {
+                            replica: number;
+                            counter: number;
+                        };
+                        side: "left" | "right";
+                        char: number;
+                    }[];
+                    deletes: {
+                        id: {
+                            replica: number;
+                            counter: number;
+                        };
+                    }[];
+                };
+                raw: string;
+            };
+            program?: {
+                functions: {
+                    key: string;
+                    body: {
+                        raw: string;
+                    };
+                    inputs: import('..').Param[];
+                    outputs: import('..').Param[];
+                    channels: {
+                        read: Record<number, string>;
+                        write: Record<number, string>;
+                    };
+                }[];
+                nodes: {
+                    key: string;
+                    type: string;
+                    inputs: import('..').Param[];
+                    outputs: import('..').Param[];
+                    channels: {
+                        read: Record<number, string>;
+                        write: Record<number, string>;
+                    };
+                }[];
+                edges: {
+                    source: {
+                        node: string;
+                        param: string;
+                    };
+                    target: {
+                        node: string;
+                        param: string;
+                    };
+                    kind: ir.EdgeKind;
+                }[];
+                authorities: {
+                    channels: Record<number, number>;
+                    default?: number | undefined;
+                };
+                root: ir.Scope;
+                wasm: Uint8Array<ArrayBuffer>;
+                outputMemoryBases: Record<string, number>;
+            } | undefined;
+            status?: {
+                key: string;
+                name: string;
+                variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
+                message: string;
+                description: string;
+                time: import('@synnaxlabs/x').TimeStamp;
+                details: {
+                    running: boolean;
+                };
+                labels?: {
+                    key: string;
+                    name: string;
+                    color: [number, number, number, number];
+                }[] | undefined;
+            } | undefined;
+        };
+    };
+} | {
+    type: "rename";
+    rename: {
+        name: string;
+    };
+} | {
+    type: "set_node";
+    setNode: {
+        node: {
+            key: string;
+            position: {
+                x: number;
+                y: number;
+            };
+        };
+    };
+} | {
+    type: "set_node_position";
+    setNodePosition: {
+        key: string;
+        position: {
+            x: number;
+            y: number;
+        };
+    };
+} | {
+    type: "set_node_inputs";
+    setNodeInputs: {
+        key: string;
+        inputs: Record<string | number, unknown>;
+    };
+} | {
+    type: "remove_node";
+    removeNode: {
+        key: string;
+    };
+} | {
+    type: "add_edge";
+    addEdge: {
+        edge: {
+            source: {
+                node: string;
+                param: string;
+            };
+            target: {
+                node: string;
+                param: string;
+            };
+            kind: ir.EdgeKind;
+            key: string;
+        };
+    };
+} | {
+    type: "remove_edge";
+    removeEdge: {
+        key: string;
+    };
+} | {
+    type: "reconnect_edge";
+    reconnectEdge: {
+        key: string;
+        source: {
+            node: string;
+            param: string;
+        };
+        target: {
+            node: string;
+            param: string;
+        };
+    };
+} | {
+    type: "insert_char";
+    insertChar: {
+        id: {
+            replica: number;
+            counter: number;
+        };
+        origin: {
+            replica: number;
+            counter: number;
+        };
+        side: "left" | "right";
+        char: number;
+    };
+} | {
+    type: "delete_char";
+    deleteChar: {
+        id: {
+            replica: number;
+            counter: number;
+        };
+    };
+} | {
+    type: "forget_chars";
+    forgetChars: {
+        ids: {
+            replica: number;
+            counter: number;
+        }[];
+    };
+})[]) => actions.ReduceAllResult<Arc, {
+    type: "create";
+    create: {
+        arc: {
+            key: string;
+            name: string;
+            mode: "text" | "graph";
+            graph: {
+                functions: {
+                    key: string;
+                    body: {
+                        raw: string;
+                    };
+                    inputs: import('..').Param[];
+                    outputs: import('..').Param[];
+                    channels: {
+                        read: Record<number, string>;
+                        write: Record<number, string>;
+                    };
+                }[];
+                edges: {
+                    source: {
+                        node: string;
+                        param: string;
+                    };
+                    target: {
+                        node: string;
+                        param: string;
+                    };
+                    kind: ir.EdgeKind;
+                    key: string;
+                }[];
+                nodes: {
+                    key: string;
+                    position: {
+                        x: number;
+                        y: number;
+                    };
+                }[];
+                inputs: Record<string, Record<string | number, unknown>>;
+            };
+            text: {
+                doc: {
+                    inserts: {
+                        id: {
+                            replica: number;
+                            counter: number;
+                        };
+                        origin: {
+                            replica: number;
+                            counter: number;
+                        };
+                        side: "left" | "right";
+                        char: number;
+                    }[];
+                    deletes: {
+                        id: {
+                            replica: number;
+                            counter: number;
+                        };
+                    }[];
+                };
+                raw: string;
+            };
+            program?: {
+                functions: {
+                    key: string;
+                    body: {
+                        raw: string;
+                    };
+                    inputs: import('..').Param[];
+                    outputs: import('..').Param[];
+                    channels: {
+                        read: Record<number, string>;
+                        write: Record<number, string>;
+                    };
+                }[];
+                nodes: {
+                    key: string;
+                    type: string;
+                    inputs: import('..').Param[];
+                    outputs: import('..').Param[];
+                    channels: {
+                        read: Record<number, string>;
+                        write: Record<number, string>;
+                    };
+                }[];
+                edges: {
+                    source: {
+                        node: string;
+                        param: string;
+                    };
+                    target: {
+                        node: string;
+                        param: string;
+                    };
+                    kind: ir.EdgeKind;
+                }[];
+                authorities: {
+                    channels: Record<number, number>;
+                    default?: number | undefined;
+                };
+                root: ir.Scope;
+                wasm: Uint8Array<ArrayBuffer>;
+                outputMemoryBases: Record<string, number>;
+            } | undefined;
+            status?: {
+                key: string;
+                name: string;
+                variant: "error" | "success" | "info" | "warning" | "loading" | "disabled";
+                message: string;
+                description: string;
+                time: import('@synnaxlabs/x').TimeStamp;
+                details: {
+                    running: boolean;
+                };
+                labels?: {
+                    key: string;
+                    name: string;
+                    color: [number, number, number, number];
+                }[] | undefined;
+            } | undefined;
+        };
+    };
+} | {
+    type: "rename";
+    rename: {
+        name: string;
+    };
+} | {
+    type: "set_node";
+    setNode: {
+        node: {
+            key: string;
+            position: {
+                x: number;
+                y: number;
+            };
+        };
+    };
+} | {
+    type: "set_node_position";
+    setNodePosition: {
+        key: string;
+        position: {
+            x: number;
+            y: number;
+        };
+    };
+} | {
+    type: "set_node_inputs";
+    setNodeInputs: {
+        key: string;
+        inputs: Record<string | number, unknown>;
+    };
+} | {
+    type: "remove_node";
+    removeNode: {
+        key: string;
+    };
+} | {
+    type: "add_edge";
+    addEdge: {
+        edge: {
+            source: {
+                node: string;
+                param: string;
+            };
+            target: {
+                node: string;
+                param: string;
+            };
+            kind: ir.EdgeKind;
+            key: string;
+        };
+    };
+} | {
+    type: "remove_edge";
+    removeEdge: {
+        key: string;
+    };
+} | {
+    type: "reconnect_edge";
+    reconnectEdge: {
+        key: string;
+        source: {
+            node: string;
+            param: string;
+        };
+        target: {
+            node: string;
+            param: string;
+        };
+    };
+} | {
+    type: "insert_char";
+    insertChar: {
+        id: {
+            replica: number;
+            counter: number;
+        };
+        origin: {
+            replica: number;
+            counter: number;
+        };
+        side: "left" | "right";
+        char: number;
+    };
+} | {
+    type: "delete_char";
+    deleteChar: {
+        id: {
+            replica: number;
+            counter: number;
+        };
+    };
+} | {
+    type: "forget_chars";
+    forgetChars: {
+        ids: {
+            replica: number;
+            counter: number;
+        }[];
+    };
+}>;
+export declare const scopedActionZ: z.ZodObject<{
+    key: z.ZodUUID;
+    dispatchKey: z.ZodString;
+    seq: z.ZodDefault<z.ZodNumber>;
+    actions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"create">;
+        create: z.ZodObject<{
+            arc: z.ZodObject<{
+                key: z.ZodDefault<z.ZodUUID>;
+                name: z.ZodString;
+                mode: z.ZodEnum<{
+                    text: "text";
+                    graph: "graph";
+                }>;
+                graph: z.ZodPrefault<z.ZodObject<{
+                    functions: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        body: z.ZodObject<{
+                            raw: z.ZodString;
+                        }, z.core.$strip>;
+                        inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        channels: z.ZodObject<{
+                            read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                            write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>>;
+                    edges: z.ZodDefault<z.ZodDefault<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.ZodEnum<typeof ir.EdgeKind>;
+                        key: z.ZodString;
+                    }, z.core.$strip>>>>;
+                    nodes: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        position: z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>>;
+                    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodUnknown>>>;
+                }, z.core.$strip>>;
+                text: z.ZodPrefault<z.ZodObject<{
+                    doc: z.ZodPrefault<z.ZodObject<{
+                        inserts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            id: z.ZodObject<{
+                                replica: z.ZodUInt32;
+                                counter: z.ZodUInt32;
+                            }, z.core.$strip>;
+                            origin: z.ZodObject<{
+                                replica: z.ZodUInt32;
+                                counter: z.ZodUInt32;
+                            }, z.core.$strip>;
+                            side: z.ZodEnum<{
+                                left: "left";
+                                right: "right";
+                            }>;
+                            char: z.ZodInt32;
+                        }, z.core.$strip>>>;
+                        deletes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            id: z.ZodObject<{
+                                replica: z.ZodUInt32;
+                                counter: z.ZodUInt32;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>>;
+                    raw: z.ZodDefault<z.ZodString>;
+                }, z.core.$strip>>;
+                program: z.ZodOptional<z.ZodObject<{
+                    functions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        body: z.ZodObject<{
+                            raw: z.ZodString;
+                        }, z.core.$strip>;
+                        inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        channels: z.ZodObject<{
+                            read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                            write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>;
+                    nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        type: z.ZodString;
+                        inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        channels: z.ZodObject<{
+                            read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                            write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>;
+                    edges: z.ZodDefault<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.ZodEnum<typeof ir.EdgeKind>;
+                    }, z.core.$strip>>>;
+                    authorities: z.ZodObject<{
+                        default: z.ZodOptional<z.ZodInt>;
+                        channels: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodInt>>;
+                    }, z.core.$strip>;
+                    root: z.ZodType<ir.Scope, unknown, z.core.$ZodTypeInternals<ir.Scope, unknown>>;
+                    wasm: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+                    outputMemoryBases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUInt32>>;
+                }, z.core.$strip>>;
+                status: z.ZodOptional<import('..').StatusZodObject<z.ZodObject<{
+                    running: z.ZodBoolean;
+                }, z.core.$strip>, z.ZodEnum<{
+                    error: "error";
+                    success: "success";
+                    info: "info";
+                    warning: "warning";
+                    loading: "loading";
+                    disabled: "disabled";
+                }>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"rename">;
+        rename: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"set_node">;
+        setNode: z.ZodObject<{
+            node: z.ZodObject<{
+                key: z.ZodString;
+                position: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"set_node_position">;
+        setNodePosition: z.ZodObject<{
+            key: z.ZodString;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"set_node_inputs">;
+        setNodeInputs: z.ZodObject<{
+            key: z.ZodString;
+            inputs: z.ZodDefault<z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"remove_node">;
+        removeNode: z.ZodObject<{
+            key: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"add_edge">;
+        addEdge: z.ZodObject<{
+            edge: 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.ZodEnum<typeof ir.EdgeKind>;
+                key: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"remove_edge">;
+        removeEdge: z.ZodObject<{
+            key: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"reconnect_edge">;
+        reconnectEdge: z.ZodObject<{
+            key: z.ZodString;
+            source: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+            target: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"insert_char">;
+        insertChar: z.ZodObject<{
+            id: z.ZodObject<{
+                replica: z.ZodUInt32;
+                counter: z.ZodUInt32;
+            }, z.core.$strip>;
+            origin: z.ZodObject<{
+                replica: z.ZodUInt32;
+                counter: z.ZodUInt32;
+            }, z.core.$strip>;
+            side: z.ZodEnum<{
+                left: "left";
+                right: "right";
+            }>;
+            char: z.ZodInt32;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"delete_char">;
+        deleteChar: z.ZodObject<{
+            id: z.ZodObject<{
+                replica: z.ZodUInt32;
+                counter: z.ZodUInt32;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"forget_chars">;
+        forgetChars: z.ZodObject<{
+            ids: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                replica: z.ZodUInt32;
+                counter: z.ZodUInt32;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+export declare const dispatchReqZ: z.ZodObject<{
+    key: z.ZodUUID;
+    dispatchKey: z.ZodString;
+    actions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"create">;
+        create: z.ZodObject<{
+            arc: z.ZodObject<{
+                key: z.ZodDefault<z.ZodUUID>;
+                name: z.ZodString;
+                mode: z.ZodEnum<{
+                    text: "text";
+                    graph: "graph";
+                }>;
+                graph: z.ZodPrefault<z.ZodObject<{
+                    functions: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        body: z.ZodObject<{
+                            raw: z.ZodString;
+                        }, z.core.$strip>;
+                        inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        channels: z.ZodObject<{
+                            read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                            write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>>;
+                    edges: z.ZodDefault<z.ZodDefault<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.ZodEnum<typeof ir.EdgeKind>;
+                        key: z.ZodString;
+                    }, z.core.$strip>>>>;
+                    nodes: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        position: z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>>;
+                    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodUnknown>>>;
+                }, z.core.$strip>>;
+                text: z.ZodPrefault<z.ZodObject<{
+                    doc: z.ZodPrefault<z.ZodObject<{
+                        inserts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            id: z.ZodObject<{
+                                replica: z.ZodUInt32;
+                                counter: z.ZodUInt32;
+                            }, z.core.$strip>;
+                            origin: z.ZodObject<{
+                                replica: z.ZodUInt32;
+                                counter: z.ZodUInt32;
+                            }, z.core.$strip>;
+                            side: z.ZodEnum<{
+                                left: "left";
+                                right: "right";
+                            }>;
+                            char: z.ZodInt32;
+                        }, z.core.$strip>>>;
+                        deletes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            id: z.ZodObject<{
+                                replica: z.ZodUInt32;
+                                counter: z.ZodUInt32;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>>;
+                    raw: z.ZodDefault<z.ZodString>;
+                }, z.core.$strip>>;
+                program: z.ZodOptional<z.ZodObject<{
+                    functions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        body: z.ZodObject<{
+                            raw: z.ZodString;
+                        }, z.core.$strip>;
+                        inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        channels: z.ZodObject<{
+                            read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                            write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>;
+                    nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        type: z.ZodString;
+                        inputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        outputs: z.ZodDefault<z.ZodArray<z.ZodType<import('..').Param, unknown, z.core.$ZodTypeInternals<import('..').Param, unknown>>>>;
+                        channels: z.ZodObject<{
+                            read: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                            write: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodString>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>;
+                    edges: z.ZodDefault<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.ZodEnum<typeof ir.EdgeKind>;
+                    }, z.core.$strip>>>;
+                    authorities: z.ZodObject<{
+                        default: z.ZodOptional<z.ZodInt>;
+                        channels: z.ZodDefault<z.ZodRecord<z.ZodUInt32, z.ZodInt>>;
+                    }, z.core.$strip>;
+                    root: z.ZodType<ir.Scope, unknown, z.core.$ZodTypeInternals<ir.Scope, unknown>>;
+                    wasm: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+                    outputMemoryBases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUInt32>>;
+                }, z.core.$strip>>;
+                status: z.ZodOptional<import('..').StatusZodObject<z.ZodObject<{
+                    running: z.ZodBoolean;
+                }, z.core.$strip>, z.ZodEnum<{
+                    error: "error";
+                    success: "success";
+                    info: "info";
+                    warning: "warning";
+                    loading: "loading";
+                    disabled: "disabled";
+                }>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"rename">;
+        rename: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"set_node">;
+        setNode: z.ZodObject<{
+            node: z.ZodObject<{
+                key: z.ZodString;
+                position: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"set_node_position">;
+        setNodePosition: z.ZodObject<{
+            key: z.ZodString;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"set_node_inputs">;
+        setNodeInputs: z.ZodObject<{
+            key: z.ZodString;
+            inputs: z.ZodDefault<z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"remove_node">;
+        removeNode: z.ZodObject<{
+            key: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"add_edge">;
+        addEdge: z.ZodObject<{
+            edge: 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.ZodEnum<typeof ir.EdgeKind>;
+                key: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"remove_edge">;
+        removeEdge: z.ZodObject<{
+            key: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"reconnect_edge">;
+        reconnectEdge: z.ZodObject<{
+            key: z.ZodString;
+            source: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+            target: z.ZodObject<{
+                node: z.ZodString;
+                param: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"insert_char">;
+        insertChar: z.ZodObject<{
+            id: z.ZodObject<{
+                replica: z.ZodUInt32;
+                counter: z.ZodUInt32;
+            }, z.core.$strip>;
+            origin: z.ZodObject<{
+                replica: z.ZodUInt32;
+                counter: z.ZodUInt32;
+            }, z.core.$strip>;
+            side: z.ZodEnum<{
+                left: "left";
+                right: "right";
+            }>;
+            char: z.ZodInt32;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"delete_char">;
+        deleteChar: z.ZodObject<{
+            id: z.ZodObject<{
+                replica: z.ZodUInt32;
+                counter: z.ZodUInt32;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"forget_chars">;
+        forgetChars: z.ZodObject<{
+            ids: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                replica: z.ZodUInt32;
+                counter: z.ZodUInt32;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+//# sourceMappingURL=actions.gen.d.ts.map