@istar-ts/core 0.7.0 → 0.8.0

package/dist/index.d.cts

@@ -68,6 +68,212 @@ export declare function isContributionLabel(value: string): value is Contributio
 /** `'istar.Goal'` → `'Goal'` */
 export declare function shortKindName(kind: ElementKind | LinkKind): string;
 //#endregion
+//#region src/constraints.d.ts
+export type ConstraintCode = "unknown-element" | "unknown-link-kind" | "invalid-source" | "invalid-target" | "actor-types-differ" | "self-link" | "duplicate-link" | "dependum-endpoint" | "same-actor" | "different-actors" | "refined-depender" | "contributed-depender" | "depender-target" | "mixed-refinement" | "contribution-and-qualification";
+export type LinkCheck = {
+  ok: true;
+} | {
+  ok: false;
+  reason: string;
+  code: ConstraintCode;
+};
+export interface CanLinkOptions<EK extends string = ElementKind, LK extends string = LinkKind> {
+  /** Default: the model's metamodel, or iStar 2.0. */
+  readonly metamodel?: Metamodel<EK, LK>;
+}
+/**
+ * Checks whether a link of `kind` may be added from `source` to `target` in `model`.
+ *
+ * For dependency links, `source` is the depender and `target` the dependee (an actor or one of
+ * its inner elements); the dependum sits between them and is not part of the check.
+ *
+ * Extended kinds (see `extendMetamodel`) are checked with the rules of the kind they behave
+ * like, or with their declarative rules, then with their extra predicate.
+ */
+export declare function canLink<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, source: string | IstarElement<EK>, target: string | IstarElement<EK>, kind: LK, options?: CanLinkOptions<EK, LK>): LinkCheck;
+/**
+ * What an extension's `check` predicate receives: the model, the endpoints, and the graph
+ * queries the iStar 2.0 rules use.
+ */
+export interface LinkRuleContext {
+  readonly model: AnyIstarModel;
+  readonly metamodel: AnyMetamodel;
+  /** The link kind being added. */
+  readonly kind: string;
+  readonly source: IstarElement<string>;
+  readonly target: IstarElement<string>;
+  /** A link (optionally of `kind`, or a kind behaving like it) joins `a` and `b`, either way. */
+  isThereLinkBetween(a: IstarElement<string>, b: IstarElement<string>, kind?: string): boolean;
+  /** `element` is the source of a link of `kind` (or a kind behaving like it). */
+  isSourceOfType(element: IstarElement<string>, kind: string): boolean;
+  /** `element` is the target of a link of `kind` (or a kind behaving like it). */
+  isTargetOfType(element: IstarElement<string>, kind: string): boolean;
+}
+export interface ModelIssue<LK extends string = LinkKind> {
+  readonly linkId: string;
+  readonly kind: LK;
+  readonly source: string;
+  readonly target: string;
+  readonly code: ConstraintCode;
+  readonly message: string;
+}
+/**
+ * Re-validates every link of a model, the way piStar does when loading a file: dependencies
+ * first (each checked before its own links are added), then the remaining links in file
+ * order, each against the graph built so far. Invalid links are reported, not removed.
+ */
+export declare function validateModel<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, options?: CanLinkOptions<EK, LK>): ModelIssue<LK>[];
+//#endregion
+//#region src/metamodels.d.ts
+export type ElementCategory = "actor" | "node";
+export type LinkCategory = "actor" | "node" | "dependency";
+/** A resolved element kind of a metamodel. */
+export interface ElementKindDefinition<K extends string = string> {
+  readonly kind: K;
+  readonly category: ElementCategory;
+  /** Human-readable name, e.g. "Goal" or "Planning". */
+  readonly label: string;
+  /** Default size; for actors the initial boundary size. */
+  readonly size: Size;
+  /** Containment rules (nodes only; actors have none). */
+  readonly info?: NodeKindInfo;
+  /** The kind whose link rules this kind follows (built-in kinds have none). */
+  readonly behavesLike?: string;
+  /** The `type` written in piStar files. Equal to `kind` unless declared otherwise. */
+  readonly pistarType: string;
+  /** Name of the extension that declared it; absent for iStar 2.0 kinds. */
+  readonly extension?: string;
+}
+/**
+ * Declarative link rules, as piStar-ext's "Create a new Construct" dialog collects them:
+ * which kinds may be the source and target. Entries are kind names (`istar.Goal`,
+ * `rationalAgents.Plan`) or categories (`node`, `actor`, `*`). A kind name also matches kinds
+ * that behave like it, so `istar.Task` accepts a Planning that behaves like a Task.
+ */
+export interface LinkRules {
+  readonly sources: readonly string[];
+  readonly targets: readonly string[];
+  /**
+   * Source and target must belong to the same actor (iStar 2.0 Guide, page 14). Default true
+   * for node links, ignored for actor links.
+   */
+  readonly sameActor?: boolean;
+  /** Allow a dependum as source or target. Default false. */
+  readonly allowDependum?: boolean;
+  /** Allow a link from an element onto itself. Default false. */
+  readonly allowSelf?: boolean;
+  /**
+   * At most one link `'kind'` of this kind, or `'any'` link at all, between the same two
+   * elements (in either direction); `false` for no limit. Default `'kind'`.
+   */
+  readonly unique?: "kind" | "any" | false;
+}
+/** A resolved link kind of a metamodel. */
+export interface LinkKindDefinition<K extends string = string> {
+  readonly kind: K;
+  readonly category: LinkCategory;
+  readonly label: string;
+  readonly info: LinkKindInfo;
+  /** The link kind whose rules (and meaning, for other rules) this kind takes on. */
+  readonly behavesLike?: string;
+  /** Declarative rules, for link kinds that don't behave like another kind. */
+  readonly rules?: LinkRules;
+  /** An extra predicate, checked after the inherited or declarative rules pass. */
+  readonly check?: (context: LinkRuleContext) => LinkCheck;
+  readonly pistarType: string;
+  readonly extension?: string;
+}
+/** A metamodel: the element and link kinds a model may use, and their rules. */
+export interface Metamodel<EK extends string = ElementKind, LK extends string = LinkKind> {
+  /** `istar-2.0`, followed by the names of the extensions applied, e.g. `istar-2.0+rationalAgents`. */
+  readonly name: string;
+  readonly extensions: readonly string[];
+  /** In declaration order: iStar 2.0 kinds first, then each extension's. */
+  readonly elements: ReadonlyMap<EK, ElementKindDefinition<EK>>;
+  readonly links: ReadonlyMap<LK, LinkKindDefinition<LK>>;
+  /** `type` in piStar files → kind. */
+  readonly elementsByPistarType: ReadonlyMap<string, EK>;
+  readonly linksByPistarType: ReadonlyMap<string, LK>;
+}
+/** The kinds of a metamodel, as type-level unions. */
+export type ElementKindOf<M> = M extends Metamodel<infer EK, string> ? EK : never;
+export type LinkKindOf<M> = M extends Metamodel<string, infer LK> ? LK : never;
+/** A metamodel of any dialect, for code that handles every kind generically. */
+export type AnyMetamodel = Metamodel<string, string>;
+/** iStar 2.0, as the piStar tool implements it. The default metamodel everywhere. */
+export declare const ISTAR_2_0: Metamodel;
+export interface ElementKindDeclaration<K extends string = string> {
+  /** Namespaced kind name, e.g. `rationalAgents.Planning`. */
+  readonly kind: K;
+  /** Default: the part after the namespace ("Planning"). */
+  readonly label?: string;
+  /** Required unless `behavesLike` is given (then it is the same category). */
+  readonly category?: ElementCategory;
+  /** An existing element kind whose link rules this kind follows, e.g. `istar.Task`. */
+  readonly behavesLike?: string;
+  /** Containment rules for nodes. Default: those of `behavesLike`, else piStar-ext's (inner, dependum). */
+  readonly info?: Partial<NodeKindInfo>;
+  /** Default: that of `behavesLike`, else piStar-ext's 90×55 for nodes and 200×120 for actors. */
+  readonly size?: Size;
+  /**
+   * The `type` used in piStar files, when it differs from `kind`. piStar-ext saves its new
+   * constructs as `istar.<Name>`, so `pistarType: 'istar.Planning'` reads its files.
+   */
+  readonly pistarType?: string;
+}
+export interface LinkKindDeclaration<K extends string = string> {
+  readonly kind: K;
+  readonly label?: string;
+  /** Default: that of `behavesLike`, else `node`. */
+  readonly category?: LinkCategory;
+  /** An existing link kind whose rules this kind takes on, e.g. `istar.OrRefinementLink`. */
+  readonly behavesLike?: string;
+  /** Declarative rules; give these or `behavesLike`, not both. */
+  readonly rules?: LinkRules;
+  /** An extra predicate, checked after the other rules pass. */
+  readonly check?: (context: LinkRuleContext) => LinkCheck;
+  /** Default: that of `behavesLike`, else none (no fixed label, no changeable value). */
+  readonly info?: LinkKindInfo;
+  readonly pistarType?: string;
+}
+/** A named set of new kinds, applied to a metamodel with `extendMetamodel`. */
+export interface MetamodelExtension<NEK extends string = string, NLK extends string = string> {
+  /** Identifies the extension, e.g. `rationalAgents`. */
+  readonly name: string;
+  readonly elements?: readonly ElementKindDeclaration<NEK>[];
+  readonly links?: readonly LinkKindDeclaration<NLK>[];
+}
+export declare class MetamodelError extends Error {
+  override name: string;
+}
+/**
+ * Declares an extension, keeping its kind names as literal types (so `extendMetamodel` can
+ * type the result). Identity at runtime.
+ */
+export declare function defineMetamodelExtension<const NEK extends string = never, const NLK extends string = never>(extension: MetamodelExtension<NEK, NLK>): MetamodelExtension<NEK, NLK>;
+/**
+ * Returns a new metamodel with the extension's kinds added. `base` is not modified.
+ *
+ * Throws `MetamodelError` when a kind name isn't namespaced, uses the reserved `istar.`
+ * prefix, collides with an existing kind or piStar type, or refers to an unknown kind.
+ */
+export declare function extendMetamodel<EK extends string, LK extends string, const NEK extends string = never, const NLK extends string = never>(base: Metamodel<EK, LK>, extension: MetamodelExtension<NEK, NLK>): Metamodel<EK | NEK, LK | NLK>;
+export declare function elementKindDefinition(metamodel: AnyMetamodel, kind: string): ElementKindDefinition | undefined;
+export declare function linkKindDefinition(metamodel: AnyMetamodel, kind: string): LinkKindDefinition | undefined;
+/** True for actor-category kinds (Actor, Agent, Role and extensions behaving like them). */
+export declare function isActorKindIn(metamodel: AnyMetamodel, kind: string): boolean;
+/** True for node-category kinds (intentional elements, built-in or extended). */
+export declare function isNodeKindIn(metamodel: AnyMetamodel, kind: string): boolean;
+/**
+ * The built-in (or rule-carrying) kind an element kind ultimately behaves like: `istar.Task`
+ * for a Planning that behaves like a Task; the kind itself when it behaves like nothing.
+ */
+export declare function effectiveElementKind(metamodel: AnyMetamodel, kind: string): string;
+/** Like `effectiveElementKind`, for link kinds. */
+export declare function effectiveLinkKind(metamodel: AnyMetamodel, kind: string): string;
+/** True when `kind` is `ancestor` or (transitively) behaves like it. */
+export declare function elementBehavesLike(metamodel: AnyMetamodel, kind: string, ancestor: string): boolean;
+//#endregion
 //#region src/model.d.ts
 /**
  * piStar stores every custom property value as a string (e.g. `"initialValue": "false"`).
@@ -94,7 +300,11 @@ export interface LinkDisplay {
   readonly vertices?: readonly Point[];
   readonly [key: string]: unknown;
 }
-export interface IstarElement<K extends ElementKind = ElementKind> {
+/**
+ * An element of the model. `K` is the kind union: iStar 2.0's by default, wider for models of an
+ * extended metamodel (see `extendMetamodel`).
+ */
+export interface IstarElement<K extends string = ElementKind> {
   readonly id: string;
   readonly kind: K;
   /** The element's label; `text` in the save file. */
@@ -120,7 +330,7 @@ export interface IstarElement<K extends ElementKind = ElementKind> {
 }
 export type IstarActor = IstarElement<ActorKind>;
 export type IstarNode = IstarElement<NodeKind>;
-export interface IstarLink<K extends LinkKind = LinkKind> {
+export interface IstarLink<K extends string = LinkKind> {
   readonly id: string;
   readonly kind: K;
   readonly source: string;
@@ -142,10 +352,12 @@ export interface Diagram {
 /**
  * An immutable iStar model. Maps preserve insertion order, which is the order elements and
  * links are written back to disk.
+ *
+ * `EK`/`LK` are the element and link kind unions; they default to iStar 2.0's.
  */
-export interface IstarModel {
-  readonly elements: ReadonlyMap<string, IstarElement>;
-  readonly links: ReadonlyMap<string, IstarLink>;
+export interface IstarModel<EK extends string = ElementKind, LK extends string = LinkKind> {
+  readonly elements: ReadonlyMap<string, IstarElement<EK>>;
+  readonly links: ReadonlyMap<string, IstarLink<LK>>;
   readonly diagram?: Diagram;
   readonly tool?: string;
   readonly istar?: string;
@@ -159,51 +371,39 @@ export interface IstarModel {
 export declare const PISTAR_TOOL = "pistar.2.1.0";
 export declare const ISTAR_VERSION = "2.0";
 export declare const DEFAULT_DIAGRAM: Diagram;
+/** A model of any dialect, for code that handles every kind generically. */
+export type AnyIstarModel = IstarModel<string, string>;
+/**
+ * Associates `metamodel` with `model` and returns the same model, typed for it. Use when a
+ * model was built without the library's operations (e.g. with an object spread), which loses
+ * the association.
+ */
+export declare function withMetamodel<EK extends string, LK extends string>(model: IstarModel<string, string>, metamodel: Metamodel<EK, LK>): IstarModel<EK, LK>;
+/** Gives `to` the metamodel of `from` (used for every model an operation derives). */
+export declare function inheritMetamodel<M extends IstarModel<string, string>>(from: IstarModel<string, string>, to: M): M;
+export declare function createEmptyModel<EK extends string, LK extends string>(diagram: Diagram | undefined, options: {
+  metamodel: Metamodel<EK, LK>;
+}): IstarModel<EK, LK>;
 export declare function createEmptyModel(diagram?: Diagram): IstarModel;
-export declare function isActor(element: IstarElement | undefined): element is IstarActor;
-export declare function isNode(element: IstarElement | undefined): element is IstarNode;
+/**
+ * The metamodel a model was read or created with (see `parsePistar`, `createEmptyModel`), or
+ * iStar 2.0. Constraints, operations and serialization use it unless given another one.
+ */
+export declare function metamodelOf<EK extends string, LK extends string>(model: IstarModel<EK, LK>): Metamodel<EK, LK>;
+/** True for actor-category elements; pass the metamodel for extended actor kinds. */
+export declare function isActor(element: IstarElement<string> | undefined, metamodel?: AnyMetamodel): element is IstarActor;
+/** True for node-category elements; pass the metamodel for extended node kinds. */
+export declare function isNode(element: IstarElement<string> | undefined, metamodel?: AnyMetamodel): element is IstarNode;
 /** Inner elements of an actor, in model order. */
-export declare function childrenOf(model: IstarModel, actorId: string): IstarElement[];
+export declare function childrenOf<EK extends string, LK extends string>(model: IstarModel<EK, LK>, actorId: string): IstarElement<EK>[];
 /** Links that have the element as source or target. */
-export declare function linksOf(model: IstarModel, elementId: string): IstarLink[];
+export declare function linksOf<EK extends string, LK extends string>(model: IstarModel<EK, LK>, elementId: string): IstarLink<LK>[];
 /** For a dependum, the two halves of its dependency: depender → dependum → dependee. */
-export declare function dependencyLinksOf(model: IstarModel, dependumId: string): {
-  inbound?: IstarLink;
-  outbound?: IstarLink;
+export declare function dependencyLinksOf<EK extends string, LK extends string>(model: IstarModel<EK, LK>, dependumId: string): {
+  inbound?: IstarLink<LK>;
+  outbound?: IstarLink<LK>;
 };
 //#endregion
-//#region src/constraints.d.ts
-export type ConstraintCode = "unknown-element" | "unknown-link-kind" | "invalid-source" | "invalid-target" | "actor-types-differ" | "self-link" | "duplicate-link" | "dependum-endpoint" | "same-actor" | "different-actors" | "refined-depender" | "contributed-depender" | "depender-target" | "mixed-refinement" | "contribution-and-qualification";
-export type LinkCheck = {
-  ok: true;
-} | {
-  ok: false;
-  reason: string;
-  code: ConstraintCode;
-};
-type ElementRef = string | IstarElement;
-/**
- * Checks whether a link of `kind` may be added from `source` to `target` in `model`.
- *
- * For `istar.DependencyLink`, `source` is the depender and `target` the dependee (an actor or
- * one of its inner elements); the dependum sits between them and is not part of the check.
- */
-export declare function canLink(model: IstarModel, source: ElementRef, target: ElementRef, kind: LinkKind): LinkCheck;
-export interface ModelIssue {
-  readonly linkId: string;
-  readonly kind: LinkKind;
-  readonly source: string;
-  readonly target: string;
-  readonly code: ConstraintCode;
-  readonly message: string;
-}
-/**
- * Re-validates every link of a model, the way piStar does when loading a file: dependencies
- * first (each checked before its own links are added), then the remaining links in file
- * order, each against the graph built so far. Invalid links are reported, not removed.
- */
-export declare function validateModel(model: IstarModel): ModelIssue[];
-//#endregion
 //#region src/serialization.d.ts
 export interface PistarElementJson {
   id: string;
@@ -254,6 +454,10 @@ export interface PistarFile {
 export declare class PistarParseError extends Error {
   override name: string;
 }
+/** Thrown by `toPistar` for a kind its metamodel doesn't know (rather than writing it wrong). */
+export declare class PistarWriteError extends Error {
+  override name: string;
+}
 /**
  * Parse-time bookkeeping that lets `toPistar` reproduce the original key order. It has no
  * meaning for the model itself and may be dropped.
@@ -265,20 +469,33 @@ export interface SourceLayout {
   readonly display: readonly string[];
 }
 /** The key order recorded when `model` was parsed, if it came from `parsePistar`. */
-export declare function getSourceLayout(model: IstarModel): SourceLayout | undefined;
+export declare function getSourceLayout<EK extends string, LK extends string>(model: IstarModel<EK, LK>): SourceLayout | undefined;
 /**
  * Carries the recorded key order over to a model derived from `from` (the store does this for
  * every edit, so saving an edited file keeps a stable diff).
  */
-export declare function inheritSourceLayout<M extends IstarModel>(from: IstarModel, to: M): M;
+export declare function inheritSourceLayout<M extends IstarModel<string, string>>(from: IstarModel<string, string>, to: M): M;
 /**
  * Parses a piStar save file (JSON text or an already-parsed object). The input is not mutated.
  *
  * Unlike the piStar tool, elements with `x` or `y` equal to 0 are kept: upstream's
  * `if (element.x && element.y)` silently drops them, which looks unintended.
  */
+export interface ParsePistarOptions<EK extends string = ElementKind, LK extends string = LinkKind> {
+  /**
+   * The metamodel whose kinds the file may use. Default iStar 2.0: any other `type` throws,
+   * as in the piStar tool. The parsed model remembers it (see `metamodelOf`).
+   */
+  readonly metamodel?: Metamodel<EK, LK>;
+}
+export declare function parsePistar<EK extends string, LK extends string>(input: string | PistarFile | Record<string, unknown>, options: ParsePistarOptions<EK, LK> & {
+  readonly metamodel: Metamodel<EK, LK>;
+}): IstarModel<EK, LK>;
+export declare function parsePistar(input: string | PistarFile | Record<string, unknown>, options: ParsePistarOptions): IstarModel;
 export declare function parsePistar(input: string | PistarFile | Record<string, unknown>): IstarModel;
 export interface ToPistarOptions {
+  /** Default: the model's metamodel, or iStar 2.0. Decides each kind's `type` and category. */
+  metamodel?: AnyMetamodel;
   /**
    * Value for `saveDate`. Defaults to the model's own `saveDate` (so a load/save round trip is
    * lossless), or the current time for models that never had one. Pass `new Date()` when
@@ -287,9 +504,9 @@ export interface ToPistarOptions {
   saveDate?: string | Date;
 }
 /** Builds the save-file object for a model. `toPistar` is this plus `JSON.stringify`. */
-export declare function toPistarObject(model: IstarModel, options?: ToPistarOptions): PistarFile;
+export declare function toPistarObject<EK extends string, LK extends string>(input: IstarModel<EK, LK>, options?: ToPistarOptions): PistarFile;
 /** Serializes a model to piStar's JSON text (2-space indentation, no trailing newline). */
-export declare function toPistar(model: IstarModel, options?: ToPistarOptions): string;
+export declare function toPistar<EK extends string, LK extends string>(model: IstarModel<EK, LK>, options?: ToPistarOptions): string;
 declare namespace operations_d_exports {
   export { AddDependencyResult, ConnectOptions, ConnectResult, ElementPatch, IdGenerator, LinkPatch, ModelOperationError, NewDependency, NewElement, NewLink, OperationContext, addDependency, addElement, connect, defaultIdGenerator, dependencyEnds, disconnect, moveElement, nestElement, removeElement, removeElements, updateDiagram, updateElement, updateLink };
 }
@@ -302,21 +519,21 @@ export declare const defaultIdGenerator: IdGenerator;
 export interface OperationContext {
   readonly createId?: IdGenerator;
 }
-export interface NewElement {
-  readonly kind: ElementKind;
+export interface NewElement<K extends string = ElementKind> {
+  readonly kind: K;
   readonly x: number;
   readonly y: number;
   readonly id?: string;
-  /** Defaults to the kind's short name ("Goal"), like piStar. */
+  /** Defaults to the kind's label ("Goal"), like piStar. */
   readonly name?: string;
   /** Actor to place the element in. Required in practice for iStar nodes (see NodeKindInfo). */
   readonly parent?: string;
   readonly customProperties?: CustomProperties;
   readonly display?: ElementDisplay;
 }
-export declare function addElement(model: IstarModel, input: NewElement, ctx?: OperationContext): {
-  model: IstarModel;
-  element: IstarElement;
+export declare function addElement<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, input: NewElement<EK>, ctx?: OperationContext): {
+  model: IstarModel<EK, LK>;
+  element: IstarElement<EK>;
 };
 export interface ElementPatch {
   readonly name?: string;
@@ -327,26 +544,27 @@ export interface ElementPatch {
     readonly [key: string]: unknown;
   } | null;
 }
-export declare function updateElement(model: IstarModel, id: string, patch: ElementPatch): IstarModel;
+export declare function updateElement<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, id: string, patch: ElementPatch): IstarModel<EK, LK>;
 /**
  * Moves an element to an absolute position. Moving an actor shifts its inner elements by the
  * same offset.
  */
-export declare function moveElement(model: IstarModel, id: string, x: number, y: number): IstarModel;
+export declare function moveElement<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, id: string, x: number, y: number): IstarModel<EK, LK>;
 /**
  * Moves an inner element into another actor (or out of any actor with `null`). The element
  * becomes the actor's last child. Links that become invalid are kept; `validateModel` reports
  * them.
  */
-export declare function nestElement(model: IstarModel, id: string, parent: string | null): IstarModel;
+export declare function nestElement<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, id: string, parent: string | null): IstarModel<EK, LK>;
 /**
  * Removes elements and everything that depends on them: inner elements of removed actors,
  * links touching removed elements, and the rest of any dependency that loses a part.
  */
-export declare function removeElements(model: IstarModel, ids: Iterable<string>): IstarModel;
-export declare function removeElement(model: IstarModel, id: string): IstarModel;
-export interface NewLink {
-  readonly kind: Exclude<LinkKind, "istar.DependencyLink">;
+export declare function removeElements<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, ids: Iterable<string>): IstarModel<EK, LK>;
+export declare function removeElement<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, id: string): IstarModel<EK, LK>;
+export interface NewLink<K extends string = LinkKind> {
+  /** Any link kind except dependency kinds (use `addDependency` for those). */
+  readonly kind: Exclude<K, DependencyLinkKind>;
   readonly source: string;
   readonly target: string;
   readonly id?: string;
@@ -364,23 +582,24 @@ export interface ConnectOptions extends OperationContext {
    */
   readonly tryReversed?: boolean;
 }
-export type ConnectResult = {
+export type ConnectResult<EK extends string = ElementKind, LK extends string = LinkKind> = {
   ok: true;
-  model: IstarModel;
-  link: IstarLink;
+  model: IstarModel<EK, LK>;
+  link: IstarLink<LK>;
   reversed: boolean;
 } | Extract<LinkCheck, {
   ok: false;
 }>;
 /** Adds a link between two elements if the iStar constraints allow it. */
-export declare function connect(model: IstarModel, input: NewLink, options?: ConnectOptions): ConnectResult;
-export interface NewDependency {
+export declare function connect<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, input: NewLink<LK>, options?: ConnectOptions): ConnectResult<EK, LK>;
+export interface NewDependency<EK extends string = ElementKind, LK extends string = LinkKind> {
   /** The depender: an actor or one of its inner elements. */
   readonly depender: string;
   /** The dependee: an actor or one of its inner elements. */
   readonly dependee: string;
   readonly dependum: {
-    readonly kind: NodeKind;
+    /** A node kind (built-in or extended) that can be a dependum. */
+    readonly kind: Exclude<EK, ActorKind>;
     readonly name?: string;
     readonly id?: string;
     /** Defaults to the midpoint between depender and dependee, as in piStar. */
@@ -388,20 +607,22 @@ export interface NewDependency {
     readonly y?: number;
     readonly customProperties?: CustomProperties;
   };
+  /** A dependency link kind. Default `istar.DependencyLink`. */
+  readonly linkKind?: LK;
   readonly linkIds?: readonly [string, string];
 }
-export type AddDependencyResult = {
+export type AddDependencyResult<EK extends string = ElementKind, LK extends string = LinkKind> = {
   ok: true;
-  model: IstarModel;
-  dependum: IstarElement;
-  links: readonly [IstarLink, IstarLink];
+  model: IstarModel<EK, LK>;
+  dependum: IstarElement<EK>;
+  links: readonly [IstarLink<LK>, IstarLink<LK>];
 } | Extract<LinkCheck, {
   ok: false;
 }>;
 /** Adds depender → dependum → dependee. */
-export declare function addDependency(model: IstarModel, input: NewDependency, options?: Omit<ConnectOptions, "tryReversed">): AddDependencyResult;
+export declare function addDependency<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, input: NewDependency<EK, LK>, options?: Omit<ConnectOptions, "tryReversed">): AddDependencyResult<EK, LK>;
 /** Removes a link. Removing either half of a dependency removes the whole dependency. */
-export declare function disconnect(model: IstarModel, id: string): IstarModel;
+export declare function disconnect<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, id: string): IstarModel<EK, LK>;
 export interface LinkPatch {
   /** `null` removes it. */
   readonly label?: string | null;
@@ -411,10 +632,10 @@ export interface LinkPatch {
     readonly [key: string]: unknown;
   } | null;
 }
-export declare function updateLink(model: IstarModel, id: string, patch: LinkPatch): IstarModel;
-export declare function updateDiagram(model: IstarModel, patch: Partial<Diagram>): IstarModel;
+export declare function updateLink<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, id: string, patch: LinkPatch): IstarModel<EK, LK>;
+export declare function updateDiagram<EK extends string = ElementKind, LK extends string = LinkKind>(model: IstarModel<EK, LK>, patch: Partial<Diagram>): IstarModel<EK, LK>;
 /** Where dependency depender/dependee currently point (see `dependencyLinksOf`). */
-export declare function dependencyEnds(model: IstarModel, dependumId: string): {
+export declare function dependencyEnds<EK extends string, LK extends string>(model: IstarModel<EK, LK>, dependumId: string): {
   depender?: string;
   dependee?: string;
 };
@@ -460,40 +681,45 @@ export type ModelChange = {
 } | {
   type: "replace";
 };
-export interface ModelChangeEvent {
-  readonly model: IstarModel;
-  readonly previous: IstarModel;
+export interface ModelChangeEvent<EK extends string = ElementKind, LK extends string = LinkKind> {
+  readonly model: IstarModel<EK, LK>;
+  readonly previous: IstarModel<EK, LK>;
   /** `undo`/`redo`/`load` carry no changes; a transaction carries all of its changes. */
   readonly changes: readonly ModelChange[];
   readonly source: "edit" | "undo" | "redo" | "load";
 }
-export type ModelListener = (event: ModelChangeEvent) => void;
-export interface ModelStoreOptions {
+export type ModelListener<EK extends string = ElementKind, LK extends string = LinkKind> = (event: ModelChangeEvent<EK, LK>) => void;
+export interface ModelStoreOptions<EK extends string = ElementKind, LK extends string = LinkKind> {
+  /**
+   * Metamodel for the default empty model, when no initial model is given. A given initial
+   * model keeps its own (see `metamodelOf`).
+   */
+  readonly metamodel?: Metamodel<EK, LK>;
   readonly createId?: IdGenerator;
   /** Maximum number of undo steps kept. Default 100. */
   readonly historyLimit?: number;
 }
-export interface ModelStore {
-  getModel(): IstarModel;
+export interface ModelStore<EK extends string = ElementKind, LK extends string = LinkKind> {
+  getModel(): IstarModel<EK, LK>;
   /** Returns an unsubscribe function. */
-  subscribe(listener: ModelListener): () => void;
-  canLink(source: string | IstarElement, target: string | IstarElement, kind: LinkKind): LinkCheck;
-  addElement(input: NewElement): IstarElement;
+  subscribe(listener: ModelListener<EK, LK>): () => void;
+  canLink(source: string | IstarElement<EK>, target: string | IstarElement<EK>, kind: LK): LinkCheck;
+  addElement(input: NewElement<EK>): IstarElement<EK>;
   updateElement(id: string, patch: ElementPatch): void;
   moveElement(id: string, x: number, y: number): void;
   nestElement(id: string, parent: string | null): void;
   removeElement(id: string): void;
   removeElements(ids: Iterable<string>): void;
   setCollapsed(actorId: string, collapsed: boolean): void;
-  connect(input: NewLink, options?: Omit<ConnectOptions, "createId">): ConnectResult;
-  addDependency(input: NewDependency, options?: Omit<ConnectOptions, "createId" | "tryReversed">): AddDependencyResult;
+  connect(input: NewLink<LK>, options?: Omit<ConnectOptions, "createId">): ConnectResult<EK, LK>;
+  addDependency(input: NewDependency<EK, LK>, options?: Omit<ConnectOptions, "createId" | "tryReversed">): AddDependencyResult<EK, LK>;
   updateLink(id: string, patch: LinkPatch): void;
   disconnect(id: string): void;
   updateDiagram(patch: Partial<Diagram>): void;
   /** Replaces the model as one undoable edit. */
-  replace(model: IstarModel): void;
+  replace(model: IstarModel<EK, LK>): void;
   /** Replaces the model and clears history (like opening a file in piStar). */
-  load(model: IstarModel): void;
+  load(model: IstarModel<EK, LK>): void;
   /**
    * Groups several edits into one undo step and one change event. Nested calls join the
    * outermost transaction. If `fn` throws, the model is rolled back.
@@ -505,6 +731,10 @@ export interface ModelStore {
   canRedo(): boolean;
   clearHistory(): void;
 }
+export declare function createModelStore<EK extends string, LK extends string>(initial: IstarModel<EK, LK>, options?: ModelStoreOptions<EK, LK>): ModelStore<EK, LK>;
+export declare function createModelStore<EK extends string, LK extends string>(initial: undefined, options: ModelStoreOptions<EK, LK> & {
+  readonly metamodel: Metamodel<EK, LK>;
+}): ModelStore<EK, LK>;
 export declare function createModelStore(initial?: IstarModel, options?: ModelStoreOptions): ModelStore;
 //#endregion
 //#region src/properties.d.ts
@@ -551,8 +781,12 @@ export interface PropertyIssue {
   key: string;
   message: string;
 }
-export interface PropertySchema<S extends PropertyShape = PropertyShape> {
-  readonly kind: ElementKind | LinkKind;
+/**
+ * Typed custom properties of one element or link kind. `K` is the kind: iStar 2.0's kinds by
+ * default; any extension kind (see `extendMetamodel`) is accepted too.
+ */
+export interface PropertySchema<S extends PropertyShape = PropertyShape, K extends string = ElementKind | LinkKind> {
+  readonly kind: K;
   readonly shape: S;
   read(source: CustomProperties | undefined | PropertyOwner): {
     values: Partial<InferProperties<S>>;
@@ -570,9 +804,9 @@ export interface PropertyOwner {
 export interface ModelPropertyIssue extends PropertyIssue {
   id: string;
 }
-export declare function defineProperties<const S extends PropertyShape>(kind: ElementKind | LinkKind, shape: S, options?: {
+export declare function defineProperties<const S extends PropertyShape, const Kind extends string = ElementKind | LinkKind>(kind: Kind, shape: S, options?: {
   validate?: (values: Partial<InferProperties<S>>) => PropertyIssue[];
-}): PropertySchema<S>;
-export declare function validateModelProperties(model: IstarModel, schemas: readonly PropertySchema[]): ModelPropertyIssue[];
+}): PropertySchema<S, Kind>;
+export declare function validateModelProperties<EK extends string, LK extends string>(model: IstarModel<EK, LK>, schemas: readonly PropertySchema<PropertyShape, string>[]): ModelPropertyIssue[];
 //#endregion
 //# sourceMappingURL=index.d.cts.map