process-graph 1.0.6 → 1.1.0

package/dist/index-CmZOswkx.d.ts

@@ -0,0 +1,512 @@
+import { z } from "zod";
+import { JsonValue, PredicateNode, PredicateNodeSchema } from "trilean";
+//#region ../../core/graph/schema/dist/ids.d.ts
+interface IdSpace {
+  /** Every declared participant. */
+  readonly participant: string;
+  /** Participants of kind "role" or "system": the ones that can act. */
+  readonly actor: string;
+  /** Participants of kind "entity": the ones whose lifecycle a state machine can track. */
+  readonly entity: string;
+  readonly event: string;
+  readonly action: string;
+  readonly element: string;
+  readonly transition: string;
+  readonly fragment: string;
+  /** The data or deliverables activities consume and produce. */
+  readonly artefact: string;
+}
+/** The open identifier space, used for models whose identifiers are only known at runtime. */
+type OpenIds = IdSpace;
+//#endregion
+//#region ../../core/graph/schema/dist/vocabulary.d.ts
+/** What a participant is: a `role` or `system` can act, an `entity` has a lifecycle a state machine can track. */
+declare const participantKinds: readonly ["role", "system", "entity"];
+type ParticipantKind = (typeof participantKinds)[number];
+declare const pseudoRoles: readonly ["initial", "final", "fork", "join", "history"];
+type PseudoRole = (typeof pseudoRoles)[number];
+declare const messageModes: readonly ["sync", "async", "reply", "create", "destroy"];
+type MessageMode = (typeof messageModes)[number];
+declare const fragmentOperators: readonly ["alt", "opt", "loop", "par", "break"];
+type FragmentOperator = (typeof fragmentOperators)[number];
+/** Where an element stands in a run: finished, still to do, or not known. Run state is supplied by sources and never stored in the model. */
+declare const overlayStatuses: readonly ["done", "open", "unknown"];
+type OverlayStatus = (typeof overlayStatuses)[number];
+declare const notations: readonly ["flowchart", "swimlane", "stateMachine", "sequence"];
+type Notation = (typeof notations)[number];
+/** The kinds of element a model declares, one per variant of `Element`. */
+declare const elementKinds: readonly ["activity", "decision", "state", "pseudo", "message"];
+type ElementKind = (typeof elementKinds)[number];
+//#endregion
+//#region ../../core/graph/schema/dist/declarations.d.ts
+interface Participant<Id extends string, Kind extends ParticipantKind = ParticipantKind> {
+  readonly id: Id;
+  readonly label: string;
+  readonly kind: Kind;
+}
+type AnyParticipants = readonly Participant<string>[];
+/** Identifiers of the declared participants whose kind is one of `Kind`. */
+type IdsOfKind<Ps extends AnyParticipants, Kind extends ParticipantKind> = Extract<Ps[number], {
+  readonly kind: Kind;
+}>["id"];
+interface EventDef<Id extends string> {
+  readonly id: Id;
+  readonly name: string;
+  readonly payload?: Readonly<Record<string, string>>;
+}
+interface ActionDef<Id extends string> {
+  readonly id: Id;
+  readonly name: string;
+}
+/**
+ * Concepts that belong to one notation only, such as an activation bar, a history pseudo-state or a pool, keyed by notation name. The model gives them no meaning, so a projection ignores them and reports that it did; they exist so a round trip through a view restores them.
+ */
+type Extensions = Readonly<Record<string, JsonValue>>;
+/**
+ * Something activities consume or produce: data, a document, a deliverable. An artefact nothing produces is an input to the process; one flagged `deliverable` is an output of it.
+ */
+interface ArtefactDef<Id extends string> {
+  readonly id: Id;
+  readonly name: string;
+  readonly deliverable?: boolean;
+}
+type Element<Id extends string, R extends IdSpace> = {
+  readonly kind: "activity";
+  readonly id: Id;
+  readonly extensions?: Extensions;
+  readonly label: string;
+  readonly actor?: R["actor"];
+  readonly action?: R["action"];
+  /**
+   * The external record this activity stands for, as a source-qualified identifier such as `github:org/repo#12`. It is the activity's identity in its source and unique across the model's activities.
+   */
+  readonly source?: string;
+  /**
+   * The entities whose lifecycle this activity changes. A state machine projection for a subject keeps the activities that affect it. Only entity participants can be named.
+   */
+  readonly affects?: readonly R["entity"][];
+  /** Artefacts this activity needs before it can run. */
+  readonly consumes?: readonly R["artefact"][];
+  /** Artefacts this activity makes. An artefact has at most one producing activity. */
+  readonly produces?: readonly R["artefact"][];
+} | {
+  readonly kind: "decision";
+  readonly id: Id;
+  readonly extensions?: Extensions;
+  readonly label: string;
+  readonly actor?: R["actor"];
+} | {
+  readonly kind: "state";
+  readonly id: Id;
+  readonly extensions?: Extensions;
+  readonly label: string;
+  readonly parent?: R["element"];
+  readonly entry?: R["action"];
+  readonly exit?: R["action"];
+} | {
+  readonly kind: "pseudo";
+  readonly id: Id;
+  readonly extensions?: Extensions;
+  readonly role: PseudoRole;
+  readonly parent?: R["element"];
+} | {
+  readonly kind: "message";
+  readonly id: Id;
+  readonly extensions?: Extensions;
+  readonly label: string;
+  readonly from: R["actor"];
+  readonly to: R["actor"];
+  readonly mode: MessageMode;
+  readonly event?: R["event"];
+};
+interface Transition<Id extends string, R extends IdSpace> {
+  readonly id: Id;
+  readonly source: R["element"];
+  readonly target: R["element"];
+  readonly trigger?: R["event"];
+  /** The human-readable label of the branch. It is never evaluated; `condition` is. */
+  readonly guard?: string;
+  /**
+   * A three-valued predicate tree that decides whether this branch is taken, as a trilean `PredicateNode`. Its references are opaque keys for the evaluator's resolvers, not identifiers of this model, so it is not parameterised by the identifier spaces.
+   */
+  readonly condition?: PredicateNode;
+  readonly effect?: R["action"];
+}
+interface FragmentOperand<R extends IdSpace> {
+  readonly guard?: string;
+  readonly body: readonly R["element"][];
+}
+interface Fragment<Id extends string, R extends IdSpace> {
+  readonly id: Id;
+  readonly operator: FragmentOperator;
+  readonly operands: readonly FragmentOperand<R>[];
+}
+/**
+ * A projection records the extra input a lossy direction needs. Flowchart and swimlane need none. A state machine needs its subject entity. A sequence diagram needs the scenario it follows.
+ */
+type Projection<R extends IdSpace> = {
+  readonly id: string;
+  readonly notation: "flowchart" | "swimlane";
+} | {
+  readonly id: string;
+  readonly notation: "stateMachine";
+  readonly subject: R["entity"];
+} | {
+  readonly id: string;
+  readonly notation: "sequence";
+  readonly scenario: readonly R["transition"][];
+};
+interface Point {
+  readonly x: number;
+  readonly y: number;
+}
+/** Layout lives apart from the semantic model, keyed by element identifier. */
+type Views<ElementId extends string> = Readonly<Partial<Record<Notation, Readonly<Partial<Record<ElementId, Point>>>>>>;
+//#endregion
+//#region ../../core/graph/schema/dist/model.d.ts
+interface ModelParts<D extends IdSpace, R extends IdSpace, Ps extends AnyParticipants = readonly Participant<D["participant"]>[]> {
+  readonly participants: Ps;
+  readonly events: readonly EventDef<D["event"]>[];
+  readonly actions: readonly ActionDef<D["action"]>[];
+  readonly artefacts: readonly ArtefactDef<D["artefact"]>[];
+  readonly elements: readonly Element<D["element"], R>[];
+  readonly transitions: readonly Transition<D["transition"], R>[];
+  readonly fragments: readonly Fragment<D["fragment"], R>[];
+  readonly projections: readonly Projection<R>[];
+  readonly views?: Views<R["element"]>;
+}
+type Model<I extends IdSpace> = ModelParts<I, I>;
+/**
+ * Declare a model. Each identifier union is inferred from the declaring arrays only, so every reference elsewhere is checked against what was declared.
+ *
+ * The participants array is captured whole, with each kind kept as a literal. Actors and message ends are then checked against the role and system participants, and a state machine subject against the entity participants.
+ */
+declare const defineModel: <const Ps extends AnyParticipants, const Ev extends string, const Ac extends string, const El extends string, const Tr extends string, const Fr extends string, const Ar extends string>(model: ModelParts<{
+  readonly participant: Ps[number]["id"];
+  readonly actor: IdsOfKind<Ps, "role" | "system">;
+  readonly entity: IdsOfKind<Ps, "entity">;
+  readonly event: Ev;
+  readonly action: Ac;
+  readonly element: El;
+  readonly transition: Tr;
+  readonly fragment: Fr;
+  readonly artefact: Ar;
+}, {
+  readonly participant: NoInfer<Ps[number]["id"]>;
+  readonly actor: NoInfer<IdsOfKind<Ps, "role" | "system">>;
+  readonly entity: NoInfer<IdsOfKind<Ps, "entity">>;
+  readonly event: NoInfer<Ev>;
+  readonly action: NoInfer<Ac>;
+  readonly element: NoInfer<El>;
+  readonly transition: NoInfer<Tr>;
+  readonly fragment: NoInfer<Fr>;
+  readonly artefact: NoInfer<Ar>;
+}, Ps>) => Model<{
+  readonly participant: Ps[number]["id"];
+  readonly actor: IdsOfKind<Ps, "role" | "system">;
+  readonly entity: IdsOfKind<Ps, "entity">;
+  readonly event: Ev;
+  readonly action: Ac;
+  readonly element: El;
+  readonly transition: Tr;
+  readonly fragment: Fr;
+  readonly artefact: Ar;
+}>;
+//#endregion
+//#region ../../core/graph/schema/dist/artefacts.d.ts
+/**
+ * The artefacts the process takes as given: those no activity produces, in declaration order.
+ * @param model - The model to read.
+ * @returns The declared artefacts that appear in no activity's `produces`.
+ */
+declare const inputsOf: <I extends IdSpace>(model: Model<I>) => readonly ArtefactDef<I["artefact"]>[];
+/**
+ * The artefacts the process exists to deliver: those flagged `deliverable`, in declaration order.
+ * @param model - The model to read.
+ * @returns The declared artefacts flagged `deliverable`.
+ */
+declare const outputsOf: <I extends IdSpace>(model: Model<I>) => readonly ArtefactDef<I["artefact"]>[];
+//#endregion
+//#region ../../core/graph/schema/dist/validate.d.ts
+type IssueCode = "duplicate-id" | "unknown-reference" | "multiple-initial" | "subject-not-entity" | "actor-is-entity" | "duplicate-source" | "multiple-producers" | "affects-not-entity" | "overlay-unknown-element";
+interface Issue {
+  readonly code: IssueCode;
+  readonly message: string;
+}
+/**
+ * Runtime validation. Authored models are already reference-safe at compile time. This is for models loaded from JSON, where identifiers are plain strings, and for the rules the type system cannot state: unique identifiers, one initial pseudo-state per scope, and entity subjects for state machine projections.
+ */
+declare const validate: <I extends IdSpace>(model: Model<I>) => readonly Issue[];
+//#endregion
+//#region ../../core/graph/schema/dist/overlay.d.ts
+/**
+ * Run state laid over a model, keyed by element identifier. It is separate from the model on purpose, the same rule as layout: a model describes a process, an overlay describes one run of it, and many overlays can sit over one model.
+ *
+ * An element with no entry has no recorded state, which is distinct from the explicit `"unknown"`, a source reporting that it cannot tell.
+ */
+type Overlay<I extends IdSpace> = Readonly<Partial<Record<I["element"], OverlayStatus>>>;
+/** The open overlay shape: element identifiers are plain strings. Its inferred type is exactly `Overlay<OpenIds>`. */
+declare const overlaySchema: z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodEnum<{
+  done: "done";
+  open: "open";
+  unknown: "unknown";
+}>>>;
+/** A shape problem found while loading an overlay. */
+interface OverlayIssue {
+  /** RFC 6901 JSON pointer to the offending value in the input; the empty string is the document itself. */
+  readonly pointer: string;
+  readonly message: string;
+}
+/** Thrown by `parseOverlay` when the input is not a valid overlay. */
+declare class OverlayParseError extends Error {
+  /** Every problem found. Never empty. */
+  readonly issues: readonly OverlayIssue[];
+  /**
+   * @param issues - The problems found. Must not be empty.
+   */
+  constructor(issues: readonly OverlayIssue[]);
+}
+/**
+ * Checks an overlay against the model it is laid over. `parseOverlay` is model-independent, so this is where an element identifier that the model does not declare is found.
+ * @param model - The model the overlay is for.
+ * @param overlay - The overlay to check.
+ * @returns One `overlay-unknown-element` issue per entry whose key is not an element of the model, in the overlay's key order. Empty when every entry names a declared element.
+ */
+declare const validateOverlay: <I extends IdSpace>(model: Model<I>, overlay: Readonly<Partial<Record<string, OverlayStatus>>>) => readonly Issue[];
+/**
+ * Loads an overlay from untrusted input, such as parsed JSON.
+ * @param input - The value to load.
+ * @returns The overlay, keyed by plain-string element identifiers.
+ * @throws OverlayParseError when the input is not an object of element identifier to `"done"`, `"open"` or `"unknown"`.
+ */
+declare const parseOverlay: (input: unknown) => Overlay<OpenIds>;
+//#endregion
+//#region ../../core/graph/schema/dist/schema.d.ts
+/**
+ * The open (runtime) shape of a model: identifiers are plain strings, so references are not checked here. `validate` checks what the shape cannot, and `parseModel` runs both.
+ *
+ * Every object is strict. The inferred type is exactly `Model<OpenIds>`, which a type-level test pins in both directions.
+ */
+declare const modelSchema: z.ZodReadonly<z.ZodObject<{
+  participants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+      role: "role";
+      system: "system";
+      entity: "entity";
+    }>;
+  }, z.core.$strict>>>>;
+  events: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    payload: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodString>>>;
+  }, z.core.$strict>>>>;
+  actions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+  }, z.core.$strict>>>>;
+  artefacts: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    deliverable: z.ZodExactOptional<z.ZodBoolean>;
+  }, z.core.$strict>>>>;
+  elements: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"activity">;
+    id: z.ZodString;
+    extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+    label: z.ZodString;
+    actor: z.ZodExactOptional<z.ZodString>;
+    action: z.ZodExactOptional<z.ZodString>;
+    source: z.ZodExactOptional<z.ZodString>;
+    affects: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    consumes: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    produces: z.ZodExactOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+  }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"decision">;
+    id: z.ZodString;
+    extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+    label: z.ZodString;
+    actor: z.ZodExactOptional<z.ZodString>;
+  }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"state">;
+    id: z.ZodString;
+    extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+    label: z.ZodString;
+    parent: z.ZodExactOptional<z.ZodString>;
+    entry: z.ZodExactOptional<z.ZodString>;
+    exit: z.ZodExactOptional<z.ZodString>;
+  }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"pseudo">;
+    id: z.ZodString;
+    extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+    role: z.ZodEnum<{
+      initial: "initial";
+      final: "final";
+      fork: "fork";
+      join: "join";
+      history: "history";
+    }>;
+    parent: z.ZodExactOptional<z.ZodString>;
+  }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"message">;
+    id: z.ZodString;
+    extensions: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>>>>;
+    label: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    mode: z.ZodEnum<{
+      sync: "sync";
+      async: "async";
+      reply: "reply";
+      create: "create";
+      destroy: "destroy";
+    }>;
+    event: z.ZodExactOptional<z.ZodString>;
+  }, z.core.$strict>>], "kind">>>;
+  transitions: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    target: z.ZodString;
+    trigger: z.ZodExactOptional<z.ZodString>;
+    guard: z.ZodExactOptional<z.ZodString>;
+    condition: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"not">;
+      operand: typeof PredicateNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"and">;
+      left: typeof PredicateNodeSchema;
+      right: typeof PredicateNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"or">;
+      left: typeof PredicateNodeSchema;
+      right: typeof PredicateNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"allOf">;
+      operands: z.ZodArray<typeof PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"anyOf">;
+      operands: z.ZodArray<typeof PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"compare">;
+      op: z.ZodEnum<{
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        eq: "eq";
+        neq: "neq";
+      }>;
+      left: typeof import("trilean").ExpressionNodeSchema;
+      right: typeof import("trilean").ExpressionNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"textCompare">;
+      op: z.ZodEnum<{
+        equals: "equals";
+        notEquals: "notEquals";
+        matches: "matches";
+        notMatches: "notMatches";
+        portableMatches: "portableMatches";
+        portableNotMatches: "portableNotMatches";
+      }>;
+      left: typeof import("trilean").ExpressionNodeSchema;
+      right: typeof import("trilean").ExpressionNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"memberOf">;
+      op: z.ZodEnum<{
+        in: "in";
+        notIn: "notIn";
+      }>;
+      operand: typeof import("trilean").ExpressionNodeSchema;
+      candidates: z.ZodArray<typeof import("trilean").ExpressionNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"exists">;
+      operand: typeof import("trilean").ExpressionNodeSchema;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"some">;
+      collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+      item: typeof PredicateNodeSchema;
+      filter: z.ZodOptional<typeof PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"every">;
+      collection: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+      item: typeof PredicateNodeSchema;
+      filter: z.ZodOptional<typeof PredicateNodeSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"treeReference">;
+      key: z.ZodType<import("trilean").JsonValue, unknown, z.core.$ZodTypeInternals<import("trilean").JsonValue, unknown>>;
+    }, z.core.$strip>], "kind">>;
+    effect: z.ZodExactOptional<z.ZodString>;
+  }, z.core.$strict>>>>;
+  fragments: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    operator: z.ZodEnum<{
+      alt: "alt";
+      opt: "opt";
+      loop: "loop";
+      par: "par";
+      break: "break";
+    }>;
+    operands: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+      guard: z.ZodExactOptional<z.ZodString>;
+      body: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>>;
+  }, z.core.$strict>>>>;
+  projections: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    notation: z.ZodEnum<{
+      flowchart: "flowchart";
+      swimlane: "swimlane";
+    }>;
+  }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    notation: z.ZodLiteral<"stateMachine">;
+    subject: z.ZodString;
+  }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    notation: z.ZodLiteral<"sequence">;
+    scenario: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>]>>>;
+  views: z.ZodExactOptional<z.ZodReadonly<z.ZodRecord<z.ZodEnum<{
+    flowchart: "flowchart";
+    swimlane: "swimlane";
+    stateMachine: "stateMachine";
+    sequence: "sequence";
+  }> & z.core.$partial, z.ZodReadonly<z.ZodRecord<z.ZodString & z.core.$partial, z.ZodReadonly<z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strict>>>>>>>;
+}, z.core.$strict>>;
+//#endregion
+//#region ../../core/graph/schema/dist/parse.d.ts
+/** A problem found while loading a model: a shape violation located by JSON pointer, or a rule `validate` reports. */
+type ModelIssue = {
+  readonly source: "schema";
+  /** RFC 6901 JSON pointer to the offending value in the input; the empty string is the document itself. */
+  readonly pointer: string;
+  readonly message: string;
+} | {
+  readonly source: "validate";
+  readonly code: IssueCode;
+  readonly message: string;
+};
+/** Thrown by `parseModel` when the input is not a valid model. */
+declare class ModelParseError extends Error {
+  /** Every problem found, in the order the schema and then `validate` reported them. Never empty. */
+  readonly issues: readonly ModelIssue[];
+  /**
+   * @param issues - The problems found. Must not be empty.
+   */
+  constructor(issues: readonly ModelIssue[]);
+}
+/**
+ * Loads a model from untrusted input, such as parsed JSON.
+ *
+ * The input is checked against the open schema first, so every shape problem is reported with the JSON pointer of the offending value. Only a well-shaped model is then passed to `validate`, whose issues are surfaced the same way.
+ * @param input - The value to load.
+ * @returns The validated model, with identifiers as plain strings.
+ * @throws ModelParseError when the input is not a well-shaped model or fails `validate`.
+ */
+declare const parseModel: (input: unknown) => Model<OpenIds>;
+//#endregion
+export { Views as A, messageModes as B, Extensions as C, Point as D, Participant as E, OverlayStatus as F, IdSpace as G, overlayStatuses as H, ParticipantKind as I, OpenIds as K, PseudoRole as L, FragmentOperator as M, MessageMode as N, Projection as O, Notation as P, elementKinds as R, EventDef as S, FragmentOperand as T, participantKinds as U, notations as V, pseudoRoles as W, ModelParts as _, Overlay as a, ArtefactDef as b, overlaySchema as c, Issue as d, IssueCode as f, Model as g, outputsOf as h, modelSchema as i, ElementKind as j, Transition as k, parseOverlay as l, inputsOf as m, ModelParseError as n, OverlayIssue as o, validate as p, parseModel as r, OverlayParseError as s, ModelIssue as t, validateOverlay as u, defineModel as v, Fragment as w, Element as x, ActionDef as y, fragmentOperators as z };