@cynodia/axiom-core 0.3.1-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AskTech AS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# Axiom Core
+
+Part of [Axiom](https://github.com/cynodia/axiom), an AI-native semantic web application
+framework.
+
+**Status: experimental / alpha.** The API may change between alpha releases.
+
+The Application Graph and its semantic model: nodes, fields, structured types,
+expressions, **locations** (addressable writable positions), edge derivation,
+validation and type inference.
+
+## Installation
+
+```bash
+npm install @cynodia/axiom-core@alpha
+```
+
+Most applications should install the facade package instead, which re-exports this one:
+
+```bash
+npm install @cynodia/axiom@alpha
+```
+
+## License
+
+MIT
+
+Copyright (c) 2026 AskTech AS.

package/dist/context.d.ts

@@ -0,0 +1,5 @@
+import type { ApplicationGraph } from './graph.js';
+import type { SemanticContext } from './infer.js';
+/** Adapts an authoring graph to the lookups static analysis needs. */
+export declare function semanticContextFromGraph(graph: ApplicationGraph): SemanticContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.js

@@ -0,0 +1,30 @@
+/** Adapts an authoring graph to the lookups static analysis needs. */
+export function semanticContextFromGraph(graph) {
+    const parameterTypes = new Map();
+    const parameterNames = new Map();
+    for (const action of graph.getNodesByKind('action')) {
+        for (const parameter of action.parameters ?? []) {
+            parameterTypes.set(parameter.id, parameter.valueType);
+            parameterNames.set(parameter.id, parameter.name);
+        }
+    }
+    for (const route of graph.getNodesByKind('route')) {
+        for (const parameter of route.parameters ?? []) {
+            parameterTypes.set(parameter.id, parameter.valueType);
+            parameterNames.set(parameter.id, parameter.name);
+        }
+    }
+    return {
+        getState: (id) => {
+            const node = graph.getNode(id);
+            return node?.kind === 'state' ? node : undefined;
+        },
+        getEntity: (id) => {
+            const node = graph.getNode(id);
+            return node?.kind === 'entity' ? node : undefined;
+        },
+        getField: (id) => graph.getField(id),
+        getParameterType: (id) => parameterTypes.get(id),
+        getName: (id) => graph.getNode(id)?.name ?? parameterNames.get(id),
+    };
+}

package/dist/derive-edges.d.ts

@@ -0,0 +1,18 @@
+import type { Expression } from './expressions.js';
+import type { NodeId } from './ids.js';
+import type { GraphEdge } from './nodes.js';
+import type { ApplicationGraph } from './graph.js';
+/** Ids a `ref` expression mentions anywhere in the tree. */
+export declare function referencedIds(expression: Expression): NodeId[];
+/**
+ * Recomputes the structural edges implied by node definitions. Edges index semantics
+ * that already exist in the nodes, so they are derived rather than hand maintained:
+ * any transformation that changes a node can simply re-run this pass.
+ *
+ * Write edges carry the fields they touch, so an agent can distinguish an action that
+ * writes one field of a record from one that replaces the record.
+ *
+ * Edges added by hand (without the `derived` marker) are preserved.
+ */
+export declare function synchronizeEdges(graph: ApplicationGraph): GraphEdge[];
+//# sourceMappingURL=derive-edges.d.ts.map

package/dist/derive-edges.js

@@ -0,0 +1,282 @@
+import { expressionFieldIds, walkExpression } from './expressions.js';
+import { locationExpressions, locationFieldIds, locationRootStateId, locationSelectorFieldIds, } from './location.js';
+import { isUINode } from './ui.js';
+/** Ids a `ref` expression mentions anywhere in the tree. */
+export function referencedIds(expression) {
+    const found = [];
+    walkExpression(expression, (node) => {
+        if (node.kind === 'ref') {
+            found.push(node.targetId);
+        }
+    });
+    return found;
+}
+function entityIdsIn(type) {
+    switch (type.kind) {
+        case 'entity':
+            return [type.entityId];
+        case 'collection':
+            return entityIdsIn(type.itemType);
+        case 'optional':
+            return entityIdsIn(type.valueType);
+        default:
+            return [];
+    }
+}
+/**
+ * Recomputes the structural edges implied by node definitions. Edges index semantics
+ * that already exist in the nodes, so they are derived rather than hand maintained:
+ * any transformation that changes a node can simply re-run this pass.
+ *
+ * Write edges carry the fields they touch, so an agent can distinguish an action that
+ * writes one field of a record from one that replaces the record.
+ *
+ * Edges added by hand (without the `derived` marker) are preserved.
+ */
+export function synchronizeEdges(graph) {
+    for (const edge of graph.listEdges()) {
+        if (edge.metadata?.derived === true) {
+            graph.removeEdge(edge.id);
+        }
+    }
+    const nodes = graph.listNodes();
+    const known = new Set(nodes.map((node) => node.id));
+    const states = new Set(nodes.filter((node) => node.kind === 'state').map((node) => node.id));
+    const pending = new Map();
+    // An iteration scope stands for an item of whatever collection its repeat reads, so a
+    // template that shows a field of the item still reads that field of the state.
+    const scopeStates = new Map();
+    for (const node of nodes) {
+        if (node.kind === 'repeat') {
+            scopeStates.set(node.id, referencedIds(node.source).filter((id) => states.has(id)));
+        }
+    }
+    const resolveStates = (id) => {
+        if (states.has(id)) {
+            return [id];
+        }
+        return scopeStates.get(id) ?? [];
+    };
+    const linker = {
+        statesFor: resolveStates,
+        link(from, to, kind, fieldIds = []) {
+            if (from === to || !known.has(from) || !known.has(to)) {
+                return;
+            }
+            const key = `${from}|${to}|${kind}`;
+            const entry = pending.get(key) ?? { from, to, kind, fieldIds: new Set() };
+            for (const fieldId of fieldIds) {
+                entry.fieldIds.add(fieldId);
+            }
+            pending.set(key, entry);
+        },
+        reads(from, expression, kind = 'reads') {
+            // Attribute a field to a state only where the expression actually reads that
+            // state's field, so "reads X.name" never over-reports.
+            const perState = new Map();
+            const referenced = new Set();
+            walkExpression(expression, (node) => {
+                if (node.kind === 'ref') {
+                    for (const stateId of resolveStates(node.targetId)) {
+                        referenced.add(stateId);
+                    }
+                }
+                if (node.kind === 'field' && node.source.kind === 'ref') {
+                    for (const stateId of resolveStates(node.source.targetId)) {
+                        const existing = perState.get(stateId) ?? new Set();
+                        existing.add(node.fieldId);
+                        perState.set(stateId, existing);
+                    }
+                }
+            });
+            for (const id of referenced) {
+                linker.link(from, id, kind, [...(perState.get(id) ?? [])]);
+            }
+        },
+        writes(from, location, kind = 'writes', extraFields = []) {
+            linker.link(from, locationRootStateId(location), kind, [
+                ...locationFieldIds(location),
+                ...extraFields,
+            ]);
+            // Addressing the location is itself a read of whatever the selectors consult.
+            for (const expression of locationExpressions(location)) {
+                linker.reads(from, expression);
+            }
+            const selectorFields = locationSelectorFieldIds(location);
+            if (selectorFields.length > 0) {
+                linker.link(from, locationRootStateId(location), 'reads', selectorFields);
+            }
+        },
+    };
+    for (const node of nodes) {
+        if (isUINode(node)) {
+            linkUiNode(node, linker);
+            continue;
+        }
+        switch (node.kind) {
+            case 'entity':
+                linkEntity(node, linker);
+                break;
+            case 'state':
+                linkState(node, linker);
+                break;
+            case 'action':
+                linkAction(node, linker);
+                break;
+            case 'constraint':
+                linkConstraint(node, linker);
+                break;
+            case 'route':
+                linker.link(node.id, node.viewId, 'routes-to');
+                break;
+            default:
+        }
+    }
+    for (const entry of pending.values()) {
+        graph.addEdge(entry.from, entry.to, entry.kind, {
+            metadata: {
+                derived: true,
+                ...(entry.fieldIds.size > 0 ? { fieldIds: [...entry.fieldIds] } : {}),
+            },
+        });
+    }
+    return graph.listEdges();
+}
+function linkEntity(entity, linker) {
+    for (const field of entity.fields) {
+        for (const target of entityIdsIn(field.valueType)) {
+            linker.link(entity.id, target, 'references', [field.id]);
+        }
+    }
+}
+function linkState(state, linker) {
+    for (const target of entityIdsIn(state.valueType)) {
+        linker.link(state.id, target, 'references');
+    }
+    if (state.derivation) {
+        linker.reads(state.id, state.derivation, 'derives-from');
+    }
+}
+function linkAction(action, linker) {
+    for (const expression of [...(action.preconditions ?? []), ...(action.postconditions ?? [])]) {
+        linker.reads(action.id, expression);
+    }
+    for (const operation of action.operations ?? []) {
+        switch (operation.kind) {
+            case 'set':
+                linker.writes(action.id, operation.target);
+                linker.reads(action.id, operation.value);
+                break;
+            case 'insert':
+                // Inserting a constructed record writes every field the record declares.
+                linker.writes(action.id, operation.target, 'writes', expressionFieldIds(operation.value));
+                linker.reads(action.id, operation.value);
+                break;
+            case 'remove':
+                linker.writes(action.id, operation.target);
+                break;
+            case 'invoke':
+                linker.link(action.id, operation.actionId, 'depends-on');
+                for (const argument of Object.values(operation.arguments ?? {})) {
+                    linker.reads(action.id, argument);
+                }
+                break;
+            case 'navigate':
+                if (operation.routeId) {
+                    linker.link(action.id, operation.routeId, 'depends-on');
+                }
+                for (const argument of Object.values(operation.parameters ?? {})) {
+                    linker.reads(action.id, argument);
+                }
+                break;
+            case 'native':
+                for (const input of Object.values(operation.inputs ?? {})) {
+                    linker.reads(action.id, input);
+                }
+                if (operation.resultTarget) {
+                    linker.writes(action.id, operation.resultTarget);
+                }
+                for (const effect of operation.declaredEffects ?? []) {
+                    if (effect.kind === 'reads-state') {
+                        linker.link(action.id, effect.stateId, 'reads');
+                    }
+                    if (effect.kind === 'writes-state') {
+                        linker.link(action.id, effect.stateId, 'writes');
+                    }
+                }
+                break;
+            default:
+        }
+    }
+}
+function linkConstraint(constraint, linker) {
+    if (constraint.entityId) {
+        linker.link(constraint.id, constraint.entityId, 'constrains', expressionFieldIds(constraint.expression));
+    }
+    linker.reads(constraint.id, constraint.expression);
+}
+function linkUiNode(node, linker) {
+    if (node.visibleWhen) {
+        linker.reads(node.id, node.visibleWhen);
+    }
+    switch (node.kind) {
+        case 'view':
+        case 'container':
+            for (const childId of node.children) {
+                linker.link(node.id, childId, 'contains');
+            }
+            return;
+        case 'form':
+            for (const childId of node.children) {
+                linker.link(node.id, childId, 'contains');
+            }
+            linker.reads(node.id, node.target);
+            if (node.submitActionId) {
+                linker.link(node.id, node.submitActionId, 'invokes');
+            }
+            return;
+        case 'conditional':
+            for (const childId of [...node.whenTrue, ...(node.whenFalse ?? [])]) {
+                linker.link(node.id, childId, 'contains');
+            }
+            linker.reads(node.id, node.condition);
+            return;
+        case 'repeat':
+            linker.link(node.id, node.templateId, 'renders');
+            if (node.emptyTemplateId) {
+                linker.link(node.id, node.emptyTemplateId, 'renders');
+            }
+            linker.reads(node.id, node.source);
+            return;
+        case 'text':
+            if (typeof node.value !== 'string') {
+                linker.reads(node.id, node.value);
+            }
+            return;
+        case 'field-display':
+            for (const id of referencedIds(node.source).flatMap((target) => linker.statesFor(target))) {
+                linker.link(node.id, id, 'reads', [node.fieldId]);
+            }
+            return;
+        case 'input':
+            // An input both reads and writes the location it is bound to.
+            if (node.binding?.location) {
+                linker.writes(node.id, node.binding.location, 'binds');
+                linker.writes(node.id, node.binding.location, 'writes');
+            }
+            if (node.options) {
+                linker.reads(node.id, node.options.source);
+            }
+            return;
+        case 'button':
+            linker.link(node.id, node.actionId, 'invokes');
+            if (typeof node.label !== 'string') {
+                linker.reads(node.id, node.label);
+            }
+            for (const argument of Object.values(node.arguments ?? {})) {
+                linker.reads(node.id, argument);
+            }
+            return;
+        default:
+    }
+}

package/dist/diagnostics.d.ts

@@ -0,0 +1,39 @@
+import type { EdgeId, FieldId, NodeId } from './ids.js';
+export interface ValidationIssue {
+    code: string;
+    message: string;
+    nodeId?: NodeId;
+    fieldId?: FieldId;
+    edgeId?: EdgeId;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationIssue[];
+    warnings: ValidationIssue[];
+}
+export declare const VALIDATION_CODES: {
+    readonly duplicateNodeId: "DUPLICATE_NODE_ID";
+    readonly duplicateFieldId: "DUPLICATE_FIELD_ID";
+    readonly danglingNodeRef: "DANGLING_NODE_REF";
+    readonly danglingFieldRef: "DANGLING_FIELD_REF";
+    readonly invalidTypeRef: "INVALID_TYPE_REF";
+    readonly invalidEdgeKind: "INVALID_EDGE_KIND";
+    readonly invalidUiChild: "INVALID_UI_CHILD";
+    readonly invalidActionRef: "INVALID_ACTION_REF";
+    readonly invalidStateRef: "INVALID_STATE_REF";
+    readonly invalidRouteView: "INVALID_ROUTE_VIEW";
+    readonly invalidExpressionRef: "INVALID_EXPRESSION_REF";
+    readonly invalidRouteParameter: "INVALID_ROUTE_PARAMETER";
+    readonly duplicateRoutePath: "DUPLICATE_ROUTE_PATH";
+    readonly missingIdentityField: "MISSING_IDENTITY_FIELD";
+    readonly unreachableUiNode: "UNREACHABLE_UI_NODE";
+    readonly unknownStateRef: "UNKNOWN_STATE_REF";
+    readonly derivedStateWrite: "DERIVED_STATE_WRITE";
+    readonly fieldNotOnEntity: "FIELD_NOT_ON_ENTITY";
+    readonly selectorOnNonCollection: "SELECTOR_ON_NON_COLLECTION";
+    readonly fieldOnNonEntity: "FIELD_ON_NON_ENTITY";
+    readonly identityFieldMismatch: "IDENTITY_FIELD_MISMATCH";
+    readonly assignmentTypeMismatch: "ASSIGNMENT_TYPE_MISMATCH";
+    readonly invalidSelectorType: "INVALID_SELECTOR_TYPE";
+};
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics.js

@@ -0,0 +1,25 @@
+export const VALIDATION_CODES = {
+    duplicateNodeId: 'DUPLICATE_NODE_ID',
+    duplicateFieldId: 'DUPLICATE_FIELD_ID',
+    danglingNodeRef: 'DANGLING_NODE_REF',
+    danglingFieldRef: 'DANGLING_FIELD_REF',
+    invalidTypeRef: 'INVALID_TYPE_REF',
+    invalidEdgeKind: 'INVALID_EDGE_KIND',
+    invalidUiChild: 'INVALID_UI_CHILD',
+    invalidActionRef: 'INVALID_ACTION_REF',
+    invalidStateRef: 'INVALID_STATE_REF',
+    invalidRouteView: 'INVALID_ROUTE_VIEW',
+    invalidExpressionRef: 'INVALID_EXPRESSION_REF',
+    invalidRouteParameter: 'INVALID_ROUTE_PARAMETER',
+    duplicateRoutePath: 'DUPLICATE_ROUTE_PATH',
+    missingIdentityField: 'MISSING_IDENTITY_FIELD',
+    unreachableUiNode: 'UNREACHABLE_UI_NODE',
+    unknownStateRef: 'UNKNOWN_STATE_REF',
+    derivedStateWrite: 'DERIVED_STATE_WRITE',
+    fieldNotOnEntity: 'FIELD_NOT_ON_ENTITY',
+    selectorOnNonCollection: 'SELECTOR_ON_NON_COLLECTION',
+    fieldOnNonEntity: 'FIELD_ON_NON_ENTITY',
+    identityFieldMismatch: 'IDENTITY_FIELD_MISMATCH',
+    assignmentTypeMismatch: 'ASSIGNMENT_TYPE_MISMATCH',
+    invalidSelectorType: 'INVALID_SELECTOR_TYPE',
+};

package/dist/expressions.d.ts

@@ -0,0 +1,83 @@
+import type { FieldId, NodeId } from './ids.js';
+import type { LiteralValue } from './nodes.js';
+/**
+ * Expressions are structured trees, never source strings. Every value reference is an
+ * identifier: `ref` resolves an id against the evaluation scope chain (route parameters,
+ * action parameters, iteration scopes, then state), and `field` reads a field by id.
+ */
+export type Expression = LiteralExpression | RefExpression | FieldExpression | ObjectExpression | BinaryExpression | UnaryExpression | CallExpression | FilterExpression | FindExpression;
+export type LiteralPrimitive = string | number | boolean | null;
+/** Literal data. Structured values are allowed; executable text is not. */
+export interface LiteralExpression {
+    kind: 'literal';
+    value: LiteralValue;
+}
+/**
+ * Resolves an identifier in the current scope chain. The target may be a state node, a
+ * route parameter, an action parameter, an entity under validation, or an iteration
+ * scope (a `repeat` node, or a `filter`/`find` expression's `scopeId`).
+ */
+export interface RefExpression {
+    kind: 'ref';
+    targetId: NodeId;
+}
+export interface FieldExpression {
+    kind: 'field';
+    source: Expression;
+    fieldId: FieldId;
+}
+/** Constructs a record keyed by field id — used to build new instances. */
+export interface ObjectExpression {
+    kind: 'object';
+    entityId?: NodeId;
+    entries: ObjectEntry[];
+}
+export interface ObjectEntry {
+    fieldId: FieldId;
+    value: Expression;
+}
+export type BinaryOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'and' | 'or' | 'add' | 'subtract' | 'multiply' | 'divide';
+export interface BinaryExpression {
+    kind: 'binary';
+    operator: BinaryOperator;
+    left: Expression;
+    right: Expression;
+}
+export type UnaryOperator = 'not' | 'negate';
+export interface UnaryExpression {
+    kind: 'unary';
+    operator: UnaryOperator;
+    operand: Expression;
+}
+/** The built-in function vocabulary. Deliberately small and domain-neutral. */
+export type BuiltinFunction = 'required' | 'is-empty' | 'length' | 'contains' | 'concat' | 'coalesce' | 'one-of' | 'count' | 'sum' | 'lowercase' | 'to-string' | 'now' | 'uuid';
+export interface CallExpression {
+    kind: 'call';
+    function: BuiltinFunction;
+    arguments: Expression[];
+}
+/** Filters a collection. `predicate` is evaluated with the current item bound to `scopeId`. */
+export interface FilterExpression {
+    kind: 'filter';
+    source: Expression;
+    scopeId: NodeId;
+    predicate: Expression;
+}
+/** Returns the first matching item, or null. */
+export interface FindExpression {
+    kind: 'find';
+    source: Expression;
+    scopeId: NodeId;
+    predicate: Expression;
+}
+export declare function literal(value: LiteralValue): LiteralExpression;
+export declare function ref(targetId: NodeId): RefExpression;
+export declare function field(source: Expression, id: FieldId): FieldExpression;
+export declare function binary(operator: BinaryOperator, left: Expression, right: Expression): BinaryExpression;
+export declare function unary(operator: UnaryOperator, operand: Expression): UnaryExpression;
+export declare function call(fn: BuiltinFunction, ...args: Expression[]): CallExpression;
+/** Visits every sub-expression, parents before children. */
+export declare function walkExpression(expression: Expression, visit: (node: Expression) => void): void;
+/** Field ids an expression reads, including nested sources and constructed records. */
+export declare function expressionFieldIds(expression: Expression): FieldId[];
+//# sourceMappingURL=expressions.d.ts.map

package/dist/expressions.js

@@ -0,0 +1,65 @@
+export function literal(value) {
+    return { kind: 'literal', value };
+}
+export function ref(targetId) {
+    return { kind: 'ref', targetId };
+}
+export function field(source, id) {
+    return { kind: 'field', source, fieldId: id };
+}
+export function binary(operator, left, right) {
+    return { kind: 'binary', operator, left, right };
+}
+export function unary(operator, operand) {
+    return { kind: 'unary', operator, operand };
+}
+export function call(fn, ...args) {
+    return { kind: 'call', function: fn, arguments: args };
+}
+/** Visits every sub-expression, parents before children. */
+export function walkExpression(expression, visit) {
+    visit(expression);
+    switch (expression.kind) {
+        case 'field':
+            walkExpression(expression.source, visit);
+            return;
+        case 'object':
+            for (const entry of expression.entries) {
+                walkExpression(entry.value, visit);
+            }
+            return;
+        case 'binary':
+            walkExpression(expression.left, visit);
+            walkExpression(expression.right, visit);
+            return;
+        case 'unary':
+            walkExpression(expression.operand, visit);
+            return;
+        case 'call':
+            for (const argument of expression.arguments) {
+                walkExpression(argument, visit);
+            }
+            return;
+        case 'filter':
+        case 'find':
+            walkExpression(expression.source, visit);
+            walkExpression(expression.predicate, visit);
+            return;
+        default:
+    }
+}
+/** Field ids an expression reads, including nested sources and constructed records. */
+export function expressionFieldIds(expression) {
+    const found = [];
+    walkExpression(expression, (node) => {
+        if (node.kind === 'field') {
+            found.push(node.fieldId);
+        }
+        if (node.kind === 'object') {
+            for (const entry of node.entries) {
+                found.push(entry.fieldId);
+            }
+        }
+    });
+    return found;
+}

package/dist/graph.d.ts

@@ -0,0 +1,55 @@
+import type { EdgeId, FieldId, NodeId } from './ids.js';
+import type { EdgeKind, FieldDef, GraphEdge } from './nodes.js';
+import type { AnyNode, ApplicationGraphData, NodeInput, NodeKind, NodeOfKind } from './types.js';
+export interface FieldIndexEntry {
+    entityId: NodeId;
+    field: FieldDef;
+}
+export interface EdgeQuery {
+    kinds?: readonly EdgeKind[];
+}
+/**
+ * The Application Graph is the canonical representation of an application. Reads return
+ * deep clones, so a node retrieved from the graph must be written back with
+ * `updateNode` for the change to take effect.
+ */
+export declare class ApplicationGraph {
+    private data;
+    private outgoing;
+    private incoming;
+    private fieldIndex;
+    constructor(id: string, name: string, version?: string);
+    get id(): string;
+    get name(): string;
+    get version(): string;
+    addNode<T extends AnyNode>(node: NodeInput<T>): NodeId;
+    getNode<T extends AnyNode = AnyNode>(id: NodeId): T | undefined;
+    hasNode(id: NodeId): boolean;
+    updateNode(node: AnyNode): void;
+    removeNode(id: NodeId): boolean;
+    getNodesByKind<K extends NodeKind>(kind: K): NodeOfKind<K>[];
+    listNodes(): AnyNode[];
+    /** Resolves a field id to its owning entity. Fields are globally identifiable. */
+    getField(id: FieldId): FieldIndexEntry | undefined;
+    listFields(): FieldIndexEntry[];
+    addEdge(from: NodeId, to: NodeId, kind: EdgeKind, options?: {
+        id?: EdgeId;
+        metadata?: Record<string, unknown>;
+    }): EdgeId;
+    removeEdge(id: EdgeId): boolean;
+    getEdge(id: EdgeId): GraphEdge | undefined;
+    listEdges(): GraphEdge[];
+    getEdges(nodeId: NodeId, query?: EdgeQuery): GraphEdge[];
+    getOutgoingEdges(nodeId: NodeId, query?: EdgeQuery): GraphEdge[];
+    getIncomingEdges(nodeId: NodeId, query?: EdgeQuery): GraphEdge[];
+    toJSON(): ApplicationGraphData;
+    serialize(): string;
+    restore(input: string | ApplicationGraphData): void;
+    static deserialize(input: string | ApplicationGraphData): ApplicationGraph;
+    private indexEdge;
+    private indexNodeFields;
+    private rebuildFieldIndex;
+    private rebuildEdgeIndexes;
+    private rebuildIndexes;
+}
+//# sourceMappingURL=graph.d.ts.map