@matter/model 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/cjs/logic/DefaultValue.js

@@ -0,0 +1,207 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DefaultValue_exports = {};
+__export(DefaultValue_exports, {
+  DefaultValue: () => DefaultValue
+});
+module.exports = __toCommonJS(DefaultValue_exports);
+var import_general = require("@matter/general");
+var import_common = require("../common/index.js");
+var import_Model = require("../models/Model.js");
+var import_FeatureMap = require("../standard/elements/FeatureMap.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function DefaultValue(model, ifValid = false) {
+  const value = castValue(model, model.default);
+  if (value === void 0) {
+    return buildValue(model, ifValid);
+  }
+  return value;
+}
+function castValue(model, modelDefault) {
+  if (modelDefault === void 0) {
+    return;
+  }
+  if (modelDefault === null) {
+    if (model.nullable) {
+      return null;
+    }
+    return;
+  }
+  const metatype = model.effectiveMetatype;
+  switch (metatype) {
+    case void 0:
+    case import_common.Metatype.any:
+      return import_common.FieldValue.unwrap(modelDefault);
+    case import_common.Metatype.integer:
+    case import_common.Metatype.float:
+      return import_common.FieldValue.numericValue(modelDefault, model.type);
+    case import_common.Metatype.enum:
+      let enumValueModel;
+      if (typeof modelDefault === "number" || typeof modelDefault === "string") {
+        enumValueModel = model.member(modelDefault);
+      }
+      if (enumValueModel) {
+        return enumValueModel.effectiveId;
+      }
+      return;
+    case import_common.Metatype.bitmap:
+      if (typeof modelDefault === "number" || typeof modelDefault === "bigint") {
+        return decodeBitmap(model, modelDefault);
+      }
+      return import_common.FieldValue.objectValue(modelDefault);
+    case import_common.Metatype.object:
+      return import_common.FieldValue.objectValue(modelDefault);
+    case import_common.Metatype.string:
+      return `${modelDefault}`;
+    case import_common.Metatype.bytes:
+      if (ArrayBuffer.isView(modelDefault)) {
+        return new Uint8Array(modelDefault.buffer, modelDefault.byteOffset, modelDefault.byteLength);
+      }
+      if (typeof modelDefault === "string") {
+        return import_general.Bytes.fromHex(modelDefault);
+      }
+      return;
+    case import_common.Metatype.date:
+      if (modelDefault instanceof Date) {
+        return modelDefault;
+      }
+      if (typeof modelDefault === "number" || typeof modelDefault === "string") return new Date(modelDefault);
+      return;
+    case import_common.Metatype.array:
+      if (Array.isArray(modelDefault)) {
+        const entry = model.member("entry");
+        if (entry?.isType) {
+          return modelDefault.map((value) => castValue(entry, value));
+        }
+        return modelDefault;
+      }
+      return;
+    case import_common.Metatype.boolean:
+      return !!modelDefault;
+    default:
+      throw new import_general.NotImplementedError(`Unsupported metatype "${metatype}"`);
+  }
+}
+function buildValue(model, ifValid) {
+  switch (model.effectiveMetatype) {
+    case import_common.Metatype.array:
+      if (!model.nullable && model.effectiveMetatype === import_common.Metatype.array && !model.constraint.min && !model.constraint.value) {
+        return [];
+      }
+      return;
+    case import_common.Metatype.object:
+      return buildObject(model, ifValid);
+    case import_common.Metatype.bitmap:
+      return buildBitmap(model);
+  }
+}
+function buildObject(model, ifValid) {
+  let result;
+  for (const child of model.conformantMembers) {
+    const name = (0, import_general.camelize)(child.name);
+    if (result && result[name] !== void 0) {
+      continue;
+    }
+    const value = child.effectiveDefault;
+    if (value !== void 0) {
+      if (!result) {
+        result = {};
+      }
+      result[name] = value;
+      continue;
+    }
+    if (ifValid && !child.nullable) {
+      return;
+    }
+  }
+  return result;
+}
+function buildBitmap(model) {
+  let result;
+  let fieldsDefined = 0;
+  for (const m of model.conformantMembers) {
+    const defaultValue = import_common.FieldValue.numericValue(m.default);
+    if (defaultValue === void 0) {
+      continue;
+    }
+    if (result === void 0) {
+      result = 0;
+    }
+    let minBit, maxBit;
+    const constraintValue = import_common.FieldValue.numericValue(m.constraint.value);
+    if (constraintValue !== void 0) {
+      minBit = constraintValue;
+      maxBit = constraintValue + 1;
+    } else {
+      minBit = import_common.FieldValue.numericValue(m.constraint.min);
+      maxBit = import_common.FieldValue.numericValue(m.constraint.max);
+    }
+    if (minBit === void 0) {
+      minBit = 0;
+    }
+    if (maxBit === void 0) {
+      maxBit = Math.trunc(Math.log2(defaultValue)) + 1;
+    }
+    for (let i = 0, mask = 1 << minBit; i < maxBit - minBit; i++, mask << 1) {
+      if (fieldsDefined & mask) {
+        continue;
+      }
+      fieldsDefined |= mask;
+      if (defaultValue & 1 << i) {
+        result |= mask;
+      }
+    }
+  }
+  return result;
+}
+function decodeBitmap(model, value) {
+  const fields = /* @__PURE__ */ new Map();
+  for (let bit = 0; Math.pow(bit, 2) <= value; bit++) {
+    if (typeof value === "bigint") {
+      if (!(value & 1n << BigInt(bit))) {
+        continue;
+      }
+    } else if (!(value & 1 << bit)) {
+      continue;
+    }
+    const definition = model.bitDefinition(bit);
+    if (!definition || definition.isDeprecated) {
+      continue;
+    }
+    const constraint = definition.effectiveConstraint;
+    if (constraint.value !== void 0) {
+      fields.set(definition, true);
+    } else if (constraint.min !== void 0) {
+      const fieldBit = 1 << bit - constraint.min;
+      fields.set(definition, (fields.get(definition) ?? 0) & fieldBit);
+    }
+  }
+  let nameGenerator;
+  if (import_Model.Model.types[import_common.ElementTag.Attribute] && model.id === import_FeatureMap.FeatureMap.id) {
+    nameGenerator = (model2) => model2.description === void 0 ? (0, import_general.camelize)(model2.name) : (0, import_general.camelize)(model2.description);
+  } else {
+    nameGenerator = (model2) => (0, import_general.camelize)(model2.name);
+  }
+  return Object.fromEntries([...fields.entries()].map(([k, v]) => [nameGenerator(k), v]));
+}
+//# sourceMappingURL=DefaultValue.js.map

package/dist/cjs/logic/DefaultValue.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/logic/DefaultValue.ts"],
+  "mappings": "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",
+  "names": ["model"]
+}

package/dist/cjs/logic/MergedModel.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Specification } from "../common/index.js";
+import { Model } from "../models/index.js";
+import { TraverseMap } from "./ModelVariantTraversal.js";
+/**
+ * Merge multiple variants of an element into a single element.
+ */
+export declare function MergedModel(revision: Specification.Revision, variants: TraverseMap, priorities?: MergedModel.Priorities): Model;
+export declare namespace MergedModel {
+    /**
+     * Priorities define rules that control how values are merged.
+     */
+    type Priorities = {
+        /**
+         * An element type or "*" to match all elements.
+         */
+        [typeName: string]: {
+            /**
+             * A field name or "*" to match all fields.
+             */
+            [fieldName: string]: string[];
+        };
+    };
+    /**
+     * A default set of priorities for the variants included with matter.js. We currently have "chip" as preferred over
+     * "spec" by default, but then have overridden to reverse this for a lot of fields.  Should probably revisit the
+     * default at some point.
+     */
+    const DefaultPriorities: Priorities;
+}
+//# sourceMappingURL=MergedModel.d.ts.map

package/dist/cjs/logic/MergedModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MergedModel.d.ts","sourceRoot":"","sources":["../../../src/logic/MergedModel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAwB,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEzE,OAAO,EAAE,KAAK,EAAc,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAyB,WAAW,EAAiB,MAAM,4BAA4B,CAAC;AAE/F;;GAEG;AACH,wBAAgB,WAAW,CACvB,QAAQ,EAAE,aAAa,CAAC,QAAQ,EAChC,QAAQ,EAAE,WAAW,EACrB,UAAU,yBAAgC,GAC3C,KAAK,CAoEP;AA2LD,yBAAiB,WAAW,CAAC;IACzB;;OAEG;IACH,KAAY,UAAU,GAAG;QACrB;;WAEG;QACH,CAAC,QAAQ,EAAE,MAAM,GAAG;YAChB;;eAEG;YACH,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;SACjC,CAAC;KACL,CAAC;IAEF;;;;OAIG;IACI,MAAM,iBAAiB,EAAE,UAsB/B,CAAC;CACL"}

package/dist/cjs/logic/MergedModel.js

@@ -0,0 +1,216 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MergedModel_exports = {};
+__export(MergedModel_exports, {
+  MergedModel: () => MergedModel
+});
+module.exports = __toCommonJS(MergedModel_exports);
+var import_general = require("@matter/general");
+var import_aspects = require("../aspects/index.js");
+var import_common = require("../common/index.js");
+var import_models = require("../models/index.js");
+var import_ModelVariantTraversal = require("./ModelVariantTraversal.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function MergedModel(revision, variants, priorities = MergedModel.DefaultPriorities) {
+  const priority = new PriorityHandler(priorities || MergedModel.DefaultPriorities);
+  const visitor = new MergeTraversal(revision, priority, (variants2, recurse) => {
+    const merged = merge(variants2);
+    if (variants2.tag === import_common.ElementTag.Cluster) {
+      reparentToCanonicalParent(revision, priority, variants2);
+    }
+    const manual = priority.get(variants2.tag, "type")[0];
+    if (merged.type && variants2.map[manual]?.type === merged.type && !variants2.map[manual].children?.length) {
+      return merged;
+    }
+    if (merged.type) {
+      for (const variant of Object.values(variants2.map)) {
+        if (variant.type === void 0) {
+          variant.type = merged.type;
+        }
+      }
+    }
+    merged.children = recurse();
+    return merged;
+  });
+  return visitor.traverse(variants);
+  function merge(variants2) {
+    const variantValues = Object.fromEntries(
+      Object.entries(variants2.map).map(([variantName, variant]) => [variantName, variant.valueOf()])
+    );
+    const keys = new Set(Object.values(variantValues).flatMap((v) => Object.keys(v)));
+    keys.delete("children");
+    const properties = Object.fromEntries([...keys].map((k) => [k, visitor.pluck(variants2.tag, k, variantValues)]));
+    if (properties.type) {
+      const type = visitor.chooseType(variants2);
+      if (type?.type !== void 0 && type?.type !== null) {
+        properties.type = type.type;
+      }
+    }
+    const constraint = new import_aspects.Constraint(properties.constraint);
+    if (constraint.desc) {
+      for (const key of priority.get("*", "constraint")) {
+        const definition = variants2.map[key]?.constraint;
+        const constraint2 = new import_aspects.Constraint(definition);
+        if (!constraint2?.empty && !constraint2?.desc) {
+          properties.constraint = definition;
+          break;
+        }
+      }
+    }
+    return import_models.Model.create(properties);
+  }
+}
+class MergeTraversal extends import_ModelVariantTraversal.ModelVariantTraversal {
+  constructor(revision, priority, visitor) {
+    super(revision, priority.get("*", "type"));
+    this.priority = priority;
+    this.visitor = visitor;
+  }
+  visit(variants, recurse) {
+    return this.visitor(variants, recurse);
+  }
+  /**
+   * Use priority rules to select a single value from available variants.
+   */
+  pluck(tag, fieldName, variantValues) {
+    const variantPriorities = this.priority.get(tag, fieldName);
+    for (const variantName of variantPriorities) {
+      const variantValue = variantValues[variantName]?.[fieldName];
+      if (variantValue !== void 0) {
+        return variantValue;
+      }
+    }
+  }
+  /**
+   * Type selection is more complicated than other fields.
+   */
+  chooseType(variants) {
+    const variantPriorities = this.priority.get(variants.tag, "type");
+    let type;
+    let metatype;
+    for (const sourceName of variantPriorities) {
+      const variant = variants.map[sourceName];
+      if (!variant) {
+        continue;
+      }
+      if (sourceName === variantPriorities[0]) {
+        return variant;
+      }
+      if (!type) {
+        type = variant;
+        if (type instanceof import_models.ValueModel) {
+          metatype = type.effectiveMetatype;
+        }
+        continue;
+      }
+      if (!(type instanceof import_models.ValueModel) || !(variant instanceof import_models.ValueModel)) {
+        continue;
+      }
+      let overridePriority;
+      const variantMetatype = variant.effectiveMetatype;
+      if (!metatype) {
+        if (variantMetatype) {
+          overridePriority = true;
+        }
+      } else if (metatype === import_common.Metatype.integer) {
+        const variantMetatype2 = variant.effectiveMetatype;
+        if (variantMetatype2 === import_common.Metatype.enum || variantMetatype2 === import_common.Metatype.bitmap) {
+          overridePriority = true;
+        }
+      }
+      if (overridePriority) {
+        type = variant;
+        metatype = variantMetatype;
+      }
+    }
+    return type;
+  }
+}
+class PriorityHandler {
+  constructor(priorities) {
+    this.priorities = priorities;
+  }
+  /**
+   * Get the priority for a specific tag and field.
+   */
+  get(typeName, fieldName) {
+    const priority = this.priorities[typeName]?.[fieldName] || this.priorities["*"]?.[fieldName] || this.priorities[typeName]?.["*"] || this.priorities["*"]?.["*"];
+    if (!priority) {
+      throw new import_general.InternalError("No default (*, *) priority available");
+    }
+    return priority;
+  }
+}
+function reparentToCanonicalParent(revision, priority, variants) {
+  const deparented = Array();
+  const traversal = new MergeTraversal(revision, priority, (variants2, recurse) => {
+    const type = traversal.chooseType(variants2);
+    if (!(type instanceof import_models.ValueModel)) {
+      recurse();
+      return;
+    }
+    if (type.base?.isSeed && import_common.Metatype.hasChildren(type.effectiveMetatype)) {
+      for (const variantName in variants2.map) {
+        const variant = variants2.map[variantName];
+        if (variant === type || variant.children.length) {
+          continue;
+        }
+        const base = variant.base;
+        if (!(base instanceof import_models.ValueModel) || base.parent?.tag !== import_common.ElementTag.Cluster || !base.children.length) {
+          continue;
+        }
+        if (base.parent?.references(base).length > 1) {
+          continue;
+        }
+        deparented.push(base);
+        variant.children = base.children;
+        variant.type = base.type;
+      }
+    }
+    recurse();
+  });
+  traversal.traverse(variants.map);
+  deparented.forEach((m) => m.parent = void 0);
+  return variants;
+}
+((MergedModel2) => {
+  MergedModel2.DefaultPriorities = {
+    "*": {
+      "*": ["local", "chip", "spec"],
+      // Prefer spec for elements that are insufficiently defined in chip
+      conformance: ["local", "spec", "chip"],
+      constraint: ["local", "spec", "chip"],
+      quality: ["local", "spec", "chip"],
+      access: ["local", "spec", "chip"],
+      // Prefer spec for element names
+      name: ["local", "spec", "chip"],
+      // Prefer spec for datatype names (must match element names)
+      type: ["local", "spec", "chip"],
+      // Prefer spec for detailed documentation
+      details: ["local", "spec", "chip"],
+      // Prefer spec for default values
+      default: ["local", "spec", "chip"]
+    }
+  };
+})(MergedModel || (MergedModel = {}));
+//# sourceMappingURL=MergedModel.js.map

package/dist/cjs/logic/MergedModel.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/logic/MergedModel.ts"],
+  "mappings": "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",
+  "names": ["variants", "constraint", "variantMetatype", "MergedModel"]
+}

package/dist/cjs/logic/ModelTraversal.d.ts

@@ -0,0 +1,184 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Access, Aspect, Constraint } from "../aspects/index.js";
+import { ElementTag } from "../common/index.js";
+import { AnyElement } from "../elements/index.js";
+import { Children } from "../models/Children.js";
+import { PropertyModel, type ClusterModel, type CommandModel, type Model, type ValueModel } from "../models/index.js";
+/**
+ * This class performs lookups of models in the scope of a specific model.  We use a class so the lookup can maintain
+ * state and guard against circular references.
+ *
+ * Any logic that requires traversal of a multi-model ownership or inheritance should use this class.
+ *
+ */
+export declare class ModelTraversal {
+    #private;
+    /**
+     * Perform an operation with iteration tracking.  If iteration depth limit
+     */
+    operation<T>(operator: () => T, toDismiss?: Model): T;
+    /**
+     * Perform an operation with a model dismissed from consideration for type lookup.
+     */
+    operationWithDismissal<T>(toDismiss: Model | undefined, operator: () => T): T;
+    /**
+     * Determine the type for a model.  This is the string name of the base model.  Usually this is simply the type
+     * field but we infer the type in some cases where it is not supplied explicitly:
+     *
+     * - Children of maps and enums are uints of corresponding size
+     * - Models that shadow another model in their parent's inheritance effectively inherit from the shadow so have
+     *   their own name as the type name
+     */
+    getTypeName(model: Model | undefined): string | undefined;
+    /**
+     * Find the model in my inheritance hierarchy that has semantic meaning. This will be the first inherited model with
+     * a metatype.
+     */
+    findMetabase(model: Model | undefined): Model | undefined;
+    /**
+     * Find the model a model derives from, if any.
+     */
+    findBase(model: Model | undefined): Model | undefined;
+    /**
+     * Find the first global model this model derives from, if any.
+     */
+    findGlobalBase(model: Model | undefined): Model | undefined;
+    /**
+     * Determine whether this model derives from another.
+     */
+    instanceOf(model: Model | undefined, other: Model | AnyElement | undefined): boolean;
+    /**
+     * Find an xref from this model or a parent.
+     */
+    findXref(model: Model | undefined): Model.CrossReference | undefined;
+    /**
+     * Find the model this model derives from that has children, if any.
+     */
+    findDefiningModel(model: ValueModel | undefined): ValueModel | undefined;
+    /**
+     * Find a child in the parent's inheritance hierarchy with the same tag and ID/name.
+     */
+    findShadow(model: Model | undefined): Model | undefined;
+    /**
+     * Get an aspect that reflects extension of any shadowed aspects.  Note that this searches the parent's inheritance
+     * and the model's inheritance. This is because aspects can be inherited by overriding an element in the parent or
+     * by direct type inheritance.  Aspects in shadowed elements take priority as they are presumably more specific.
+     */
+    findAspect(model: Model | undefined, symbol: symbol): Aspect<any> | undefined;
+    /**
+     * Constraint aspects are specialized because we infer constraint fields that are referenced in other models.
+     */
+    findConstraint(model: ValueModel, symbol: symbol, field?: "value" | "min" | "max"): Constraint | undefined;
+    /**
+     * Access aspects are specialized because access controls are inherited from the owner if not otherwise defined.
+     *
+     * That means access controls may come from 5 places, in order of priority:
+     *
+     *   1. The model itself
+     *   2. A shadowed model in the owner hierarchy
+     *   3. An overridden model in the model's class hierarchy
+     *   4. A model in the parent hierarchy
+     *   5. Access.Default
+     *
+     * This method uses {@link findAspect} for 1-3 then extends the result with 4 & 5 as necessary until
+     * {@link Access.complete} is true.
+     */
+    findAccess(model: ValueModel | undefined, symbol: symbol, VM: typeof ValueModel): Access;
+    /**
+     * Search inherited scope for a named member.
+     */
+    findMember(scope: Model | undefined, key: Children.Selector, allowedTags: ElementTag[]): Model | undefined;
+    /**
+     * Retrieve all children of a specific type, including those inherited from the base or a shadow.  Does not include
+     * members overridden by a deeper member.
+     */
+    findChildren(scope: Model, tags: ElementTag[]): Model<import("../elements/BaseElement.js").BaseElement>[];
+    /**
+     * Filter a model's members as follows:
+     *
+     *   - If the member is deprecated, ignore it
+     *
+     *   - If there is only a single member of a given name, select that member
+     *
+     *   - If there are multiple members with the same name but there is no cluster throw an error
+     *
+     *   - If there are multiple members with the same name, use conformance to select the member that is applicable
+     *     based on active features in the provided cluster
+     *
+     *   - If there are multiple applicable members based on conformance the definitions conflict and throw an error
+     *
+     * Note that "active" in this case does not imply the member is conformant, only that conflicts are resolved.
+     *
+     * Note 2 - members may not be differentiated with conformance rules that rely on field values in this way. That
+     * will probably never be necessary and would require an entirely different (more complicated) structure.
+     */
+    findActiveMembers(scope: Model & {
+        members: PropertyModel[];
+    }, conformantOnly: boolean, cluster?: ClusterModel): ValueModel<import("../elements/ValueElement.js").ValueElement>[];
+    /**
+     * Search inherited scope for a bit definition.
+     */
+    findBitDefinition(scope: Model | undefined, bit: number): import("../models/FieldModel.js").FieldModel<import("../elements/FieldElement.js").FieldElement> | undefined;
+    /**
+     * Search inherited and structural type scope for a named type.
+     */
+    findType(scope: Model | undefined, name: string, tag: ElementTag): Model | undefined;
+    /**
+     * Similar to findType but operates with a qualified type name.
+     *
+     * Unlike findType, a qualified type may reference an element parented by any other, not just those with
+     * parent.isTypeScope === true.
+     *
+     * This is quite complicated and would be painfully slow except in practice we don't use many qualified types and
+     * those we do use resolve with few failing branches in the search once the root qualifier of the name matches.
+     */
+    findQualifiedType(scope: Model | undefined, path: string[], tag: ElementTag): Model | undefined;
+    /**
+     * Find the response model for a command.
+     */
+    findResponse(command: CommandModel): Model<import("../elements/BaseElement.js").BaseElement> | undefined;
+    /**
+     * Find all children of a node that reference a specific type.
+     */
+    findReferences(scope: Model | undefined, type: Model | undefined): Model[];
+    /**
+     * Find an owning model of a specific type.
+     */
+    findOwner<T extends Model>(constructor: Model.Type<T>, model: Model | undefined): T | undefined;
+    /**
+     * Find the root model.
+     */
+    findRoot(model: Model | undefined): Model | undefined;
+    /**
+     * Visit all nodes in the model tree.
+     */
+    visit(model: Model, visitor: (model: Model) => boolean | void): boolean | undefined;
+    /**
+     * Visit all nodes in the inheritance hierarchy until the visitor returns false.
+     */
+    visitInheritance(model: Model | undefined, visitor: (model: Model) => boolean | void): boolean | undefined;
+    /**
+     * Find the parent for this model.
+     */
+    findParent(model?: Model): Model<import("../elements/BaseElement.js").BaseElement> | undefined;
+    /**
+     * Find an owner that defines type scope for a model.
+     */
+    findScope(model?: Model): Model | undefined;
+    /**
+     * If a model is not owned by a MatterModel, global resolution won't work.  This model acts as a fallback to work
+     * around this.
+     */
+    static fallbackScope: Model | undefined;
+    /**
+     * This is a cheap hack to optimize analysis of large static models.  It temporarily memoizes key operations.
+     *
+     * It's not a huge win but does speed up model validation by approximately 50%
+     */
+    static memoize(fn: () => void): void;
+}
+//# sourceMappingURL=ModelTraversal.d.ts.map