@graview/studio 0.0.0-stage → 0.1.0

package/dist/meta.d.ts

@@ -0,0 +1,2648 @@
+import { type AnyMutationDefinition, type GraviewApp } from "@graview/core";
+import { z } from "zod";
+/**
+ * The id namespace for a kind the app declares.
+ *
+ * Deliberately NOT `kind:`, which `@graview/layout` mints its district card
+ * ids in (`KIND_PREFIX`). A node and a card sharing an id is a node the
+ * scene cannot place, an edge drawn to the wrong district, and a `#sel=`
+ * that names two different things.
+ */
+export declare const DECLARED_KIND = "declared:";
+export declare const FIELD_TYPES: readonly ["string", "text", "number", "boolean", "date", "enum", "list"];
+export type FieldType = (typeof FIELD_TYPES)[number];
+export declare const kindNode: import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>;
+export declare const fieldNode: import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>;
+export declare const edgeNode: import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>;
+export declare const actNode: import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>;
+export declare const ruleNode: import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>;
+export declare const roleNode: import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>;
+export declare const grantNode: import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>;
+export declare const lensNode: import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>;
+export declare const brandNode: import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>;
+export declare const STUDIO_SCHEMA: import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>;
+export type StudioSchema = typeof STUDIO_SCHEMA;
+export declare const addKind: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const renameKind: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const removeKind: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const addField: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const removeField: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const addEdge: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const removeEdge: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const addAct: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const removeAct: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const addRule: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const removeRule: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const nameRepair: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const forgetRepair: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const setFigure: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const addRole: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const grant: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const revokeGrant: AnyMutationDefinition<import("@graview/core").Schema<readonly [import("@graview/core").NodeDefinition<"kind", z.ZodObject<{
+    label: z.ZodString;
+    plural: z.ZodOptional<z.ZodString>;
+    noun: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    lifecycleField: z.ZodOptional<z.ZodString>;
+    retired: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    figure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"field", z.ZodObject<{
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+    }>;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    readonly of: {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it belongs to";
+        readonly inverse: "its fields";
+    };
+}>, import("@graview/core").NodeDefinition<"edge", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>;
+    appendOnly: z.ZodBoolean;
+    toAny: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly "from-kind": {
+        readonly to: readonly ["kind"];
+        readonly cardinality: "one";
+        readonly description: "the kind it is declared on";
+        readonly inverse: "its edges";
+    };
+    readonly "to-kind": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it may reach";
+        readonly inverse: "the edges that reach it";
+    };
+}>, import("@graview/core").NodeDefinition<"act", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodBoolean;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subjectArg: z.ZodOptional<z.ZodString>;
+    targetArg: z.ZodOptional<z.ZodString>;
+    onAny: z.ZodBoolean;
+    derived: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly on: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it acts on";
+        readonly inverse: "the acts on it";
+    };
+    readonly creates: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it brings into being";
+        readonly inverse: "how one comes to be";
+    };
+    readonly connects: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it makes";
+        readonly inverse: "the acts that make it";
+    };
+    readonly severs: {
+        readonly to: readonly ["edge"];
+        readonly description: "the relation it breaks";
+        readonly inverse: "the acts that break it";
+    };
+}>, import("@graview/core").NodeDefinition<"rule", z.ZodObject<{
+    label: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    judgesPast: z.ZodBoolean;
+    wholeGraph: z.ZodBoolean;
+    derivedRepairs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, {
+    readonly over: {
+        readonly to: readonly ["kind"];
+        readonly description: "the kind it judges";
+        readonly inverse: "the rules over it";
+    };
+    readonly repairs: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts that put it right";
+        readonly inverse: "the rules it repairs";
+    };
+}>, import("@graview/core").NodeDefinition<"role", z.ZodObject<{
+    label: z.ZodString;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"grant", z.ZodObject<{
+    label: z.ZodString;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodBoolean;
+    everyone: z.ZodBoolean;
+    allActs: z.ZodBoolean;
+    allKinds: z.ZodBoolean;
+}, z.core.$strip>, {
+    readonly lets: {
+        readonly to: readonly ["role"];
+        readonly description: "the roles it lets";
+        readonly inverse: "what they are let do";
+    };
+    readonly may: {
+        readonly to: readonly ["act"];
+        readonly description: "the acts it allows";
+        readonly inverse: "who may take it";
+    };
+    readonly "allows-on": {
+        readonly to: readonly ["kind"];
+        readonly description: "the kinds it allows those acts on";
+        readonly inverse: "who may act on it";
+    };
+}>, import("@graview/core").NodeDefinition<"lens", z.ZodObject<{
+    label: z.ZodString;
+    binds: z.ZodOptional<z.ZodEnum<{
+        fields: "fields";
+        entities: "entities";
+    }>>;
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>, import("@graview/core").NodeDefinition<"brand", z.ZodObject<{
+    label: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    display: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, import("@graview/core").EmptyEdgeMap>]>>;
+export declare const STUDIO_MUTATIONS: readonly AnyMutationDefinition<StudioSchema>[];
+/** The studio as an app: the meta-schema, its acts, and an agent seat that may propose any of them. */
+export declare function studioApp(name?: string): GraviewApp<StudioSchema>;
+//# sourceMappingURL=meta.d.ts.map