@itwin/presentation-hierarchies 0.5.0 → 0.7.0

package/lib/cjs/hierarchies/imodel/IModelHierarchyNode.d.ts

@@ -0,0 +1,234 @@
+import { ConcatenatedValue, InstanceKey, OmitOverUnion, PrimitiveValue } from "@itwin/presentation-shared";
+import { GroupingHierarchyNode, NonGroupingHierarchyNode } from "../HierarchyNode";
+import { GenericNodeKey, InstancesNodeKey } from "../HierarchyNodeKey";
+/**
+ * Base processing parameters that apply to every node.
+ * @beta
+ */
+interface HierarchyNodeProcessingParamsBase {
+    /** Indicates if this node should be hidden if it has no child nodes. */
+    hideIfNoChildren?: boolean;
+    /** Indicates that this node should always be hidden and its children should be loaded in its place. */
+    hideInHierarchy?: boolean;
+}
+/**
+ * A data structure for defining nodes' grouping requirements.
+ * @beta
+ */
+interface HierarchyNodeGroupingParams {
+    byLabel?: HierarchyNodeLabelGroupingParams;
+    byClass?: boolean | HierarchyNodeGroupingParamsBase;
+    byBaseClasses?: HierarchyNodeBaseClassGroupingParams;
+    byProperties?: HierarchyNodePropertiesGroupingParams;
+}
+/**
+ * A data structure for defining params specifically used for label grouping.
+ * @beta
+ */
+interface HierarchyNodeLabelGroupingBaseParams {
+    /** Label grouping option that determines whether to group nodes or to merge them. Defaults to "group".*/
+    action?: "group" | "merge";
+    /** Value that needs to match in order for nodes to be grouped or merged.*/
+    groupId?: string;
+}
+/**
+ * A data structure for defining label merging.
+ * @beta
+ */
+interface HierarchyNodeLabelGroupingMergeParams extends HierarchyNodeLabelGroupingBaseParams {
+    action: "merge";
+}
+/**
+ * A data structure for defining label grouping with additional parameters.
+ * @beta
+ */
+interface HierarchyNodeLabelGroupingGroupParams extends HierarchyNodeLabelGroupingBaseParams, HierarchyNodeGroupingParamsBase {
+    action?: "group";
+}
+/**
+ * A data structure for defining possible label grouping types.
+ * @beta
+ */
+export type HierarchyNodeLabelGroupingParams = boolean | HierarchyNodeLabelGroupingMergeParams | HierarchyNodeLabelGroupingGroupParams;
+/**
+ * Grouping parameters that are shared across all types of groupings.
+ * @beta
+ */
+export interface HierarchyNodeGroupingParamsBase {
+    /** Hiding option that determines whether to hide group nodes which have no siblings at the same hierarchy level. */
+    hideIfNoSiblings?: boolean;
+    /** Hiding option that determines whether to hide group nodes which have only one node as its children. */
+    hideIfOneGroupedNode?: boolean;
+    /** Option which auto expands grouping nodes' children when it has single child or always. */
+    autoExpand?: HierarchyNodeAutoExpandProp;
+}
+/**
+ * Defines possible values for `BaseGroupingParams.autoExpand` attribute:
+ * - `single-child` - set the grouping node to auto-expand if it groups a single node.
+ * - `always` - always set the grouping node to auto-expand.
+ * @beta
+ */
+export type HierarchyNodeAutoExpandProp = "single-child" | "always";
+/**
+ * A data structure that represents base class grouping.
+ * @beta
+ */
+interface HierarchyNodeBaseClassGroupingParams extends HierarchyNodeGroupingParamsBase {
+    /**
+     * Full names of classes, which should be used to group the node. Only has effect if the node
+     * represents an instance of that class.
+     *
+     * Full class name format: `SchemaName.ClassName`.
+     */
+    fullClassNames: string[];
+}
+/**
+ * A data structure that represents properties grouping.
+ * @beta
+ */
+export interface HierarchyNodePropertiesGroupingParams extends HierarchyNodeGroupingParamsBase {
+    /**
+     * Full name of a class whose properties are used to group the node. Only has effect if the node
+     * represents an instance of that class.
+     *
+     * Full class name format: `SchemaName.ClassName`.
+     */
+    propertiesClassName: string;
+    /**
+     * Property grouping option that determines whether to group nodes whose grouping value is not set or is set to an empty string.
+     *
+     * Label of the created grouping node will be `Not Specified`.
+     */
+    createGroupForUnspecifiedValues?: boolean;
+    /**
+     * Property grouping option that determines whether to group nodes whose grouping value doesn't fit within any of the provided
+     * ranges, or is not a numeric value.
+     *
+     * Label of the created grouping node will be `Other`.
+     */
+    createGroupForOutOfRangeValues?: boolean;
+    /**
+     * Properties of the specified class, by which the nodes should be grouped. Each provided group definition results in a
+     * grouping hierarchy level.
+     *
+     * Example usage:
+     * ```ts
+     * propertyGroups: [
+     *   {
+     *     propertyName: "type",
+     *     propertyValue: "Wall"
+     *   },
+     *   {
+     *     propertyName: "length",
+     *     propertyValue: 15,
+     *     ranges: [
+     *       { fromValue: 1, toValue: 10, rangeLabel: "Small" },
+     *       { fromValue: 11, toValue: 20, rangeLabel: "Medium" }
+     *     ]
+     *   },
+     * ]
+     * ```
+     */
+    propertyGroups: HierarchyNodePropertyGroup[];
+}
+/**
+ * A data structure that represents specific properties' grouping params.
+ * @beta
+ */
+export interface HierarchyNodePropertyGroup {
+    /** A string indicating the name of the property to group by. */
+    propertyName: string;
+    /**  Value of the property, which will be used to group the node. */
+    propertyValue?: PrimitiveValue | ConcatenatedValue;
+    /** Ranges are used to group nodes by numeric properties which are within specified bounds. */
+    ranges?: HierarchyNodePropertyValueRange[];
+}
+/**
+ * A data structure that represents boundaries for a value.
+ * @beta
+ */
+export interface HierarchyNodePropertyValueRange {
+    /** Defines the lower bound of the range. */
+    fromValue: number;
+    /** Defines the upper bound of the range. */
+    toValue: number;
+    /** Defines the range label. Will be used as `PropertyValueRangeGroupingNode` node's display label. */
+    rangeLabel?: string;
+}
+/**
+ * Processing parameters that apply to instance nodes.
+ * @beta
+ */
+export interface InstanceHierarchyNodeProcessingParams extends HierarchyNodeProcessingParamsBase {
+    grouping?: HierarchyNodeGroupingParams;
+}
+/**
+ * A generic (not based on data in an iModel) node that has processing parameters.
+ * @beta
+ */
+export type ProcessedGenericHierarchyNode = Omit<NonGroupingHierarchyNode, "key" | "children"> & {
+    key: GenericNodeKey;
+    children?: boolean;
+    processingParams?: HierarchyNodeProcessingParamsBase;
+};
+/**
+ * An instances' (based on data in an iModel) node that has processing parameters.
+ * @beta
+ */
+export type ProcessedInstanceHierarchyNode = Omit<NonGroupingHierarchyNode, "key" | "children"> & {
+    key: InstancesNodeKey;
+    children?: boolean;
+    processingParams?: InstanceHierarchyNodeProcessingParams;
+};
+/**
+ * A grouping node that groups either instance nodes or other grouping nodes.
+ * @beta
+ */
+export type ProcessedGroupingHierarchyNode = Omit<GroupingHierarchyNode, "children"> & {
+    children: Array<ProcessedGroupingHierarchyNode | ProcessedInstanceHierarchyNode>;
+};
+/**
+ * A `HierarchyNode` that may have processing parameters defining whether it should be hidden under some conditions,
+ * how it should be grouped, sorted, etc.
+ *
+ * Type guards under `HierarchyNode` namespace can be used to differentiate between different sub-types of
+ * `ProcessedHierarchyNode`.
+ *
+ * @beta
+ */
+export type ProcessedHierarchyNode = ProcessedGenericHierarchyNode | ProcessedInstanceHierarchyNode | ProcessedGroupingHierarchyNode;
+/** @beta */
+export declare namespace ProcessedHierarchyNode {
+    /** Checks whether the given node is a generic node */
+    function isGeneric(node: ProcessedHierarchyNode): node is ProcessedGenericHierarchyNode;
+    /** Checks whether the given node is an ECInstances-based node */
+    function isInstancesNode(node: ProcessedHierarchyNode): node is ProcessedInstanceHierarchyNode;
+    /** Checks whether the given node is a grouping node */
+    function isGroupingNode(node: ProcessedHierarchyNode): node is ProcessedGroupingHierarchyNode;
+}
+/**
+ * A `ProcessedHierarchyNode` that has an unformatted label in a form of `ConcatenatedValue`. Generally this is
+ * returned by hierarchy definitions as a generic node or when the node is just parsed from query results.
+ * @beta
+ */
+export type SourceHierarchyNode<TBase = SourceGenericHierarchyNode | SourceInstanceHierarchyNode> = OmitOverUnion<TBase, "label" | "parentKeys"> & {
+    label: string | ConcatenatedValue;
+};
+/**
+ * A kind of `ProcessedGenericHierarchyNode` that has unformatted label and doesn't know about its ancestors.
+ * @beta
+ */
+export type SourceGenericHierarchyNode = SourceHierarchyNode<Omit<ProcessedGenericHierarchyNode, "key"> & {
+    key: string;
+}>;
+/**
+ * A kind of `ProcessedInstanceHierarchyNode` that has unformatted label and doesn't know about its ancestors.
+ * @beta
+ */
+export type SourceInstanceHierarchyNode = SourceHierarchyNode<Omit<ProcessedInstanceHierarchyNode, "key"> & {
+    key: Omit<InstancesNodeKey, "instanceKeys"> & {
+        instanceKeys: InstanceKey[];
+    };
+}>;
+export {};
+//# sourceMappingURL=IModelHierarchyNode.d.ts.map

package/lib/cjs/hierarchies/imodel/IModelHierarchyNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IModelHierarchyNode.d.ts","sourceRoot":"","sources":["../../../../src/hierarchies/imodel/IModelHierarchyNode.ts"],"names":[],"mappings":"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"}

package/lib/cjs/hierarchies/imodel/IModelHierarchyNode.js

@@ -0,0 +1,29 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessedHierarchyNode = void 0;
+const HierarchyNodeKey_1 = require("../HierarchyNodeKey");
+/** @beta */
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+var ProcessedHierarchyNode;
+(function (ProcessedHierarchyNode) {
+    /** Checks whether the given node is a generic node */
+    function isGeneric(node) {
+        return HierarchyNodeKey_1.HierarchyNodeKey.isGeneric(node.key);
+    }
+    ProcessedHierarchyNode.isGeneric = isGeneric;
+    /** Checks whether the given node is an ECInstances-based node */
+    function isInstancesNode(node) {
+        return HierarchyNodeKey_1.HierarchyNodeKey.isInstances(node.key);
+    }
+    ProcessedHierarchyNode.isInstancesNode = isInstancesNode;
+    /** Checks whether the given node is a grouping node */
+    function isGroupingNode(node) {
+        return HierarchyNodeKey_1.HierarchyNodeKey.isGrouping(node.key);
+    }
+    ProcessedHierarchyNode.isGroupingNode = isGroupingNode;
+})(ProcessedHierarchyNode || (exports.ProcessedHierarchyNode = ProcessedHierarchyNode = {}));
+//# sourceMappingURL=IModelHierarchyNode.js.map

package/lib/cjs/hierarchies/imodel/IModelHierarchyNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IModelHierarchyNode.js","sourceRoot":"","sources":["../../../../src/hierarchies/imodel/IModelHierarchyNode.ts"],"names":[],"mappings":";AAAA;;;gGAGgG;;;AAIhG,0DAAyF;AAuNzF,YAAY;AACZ,2DAA2D;AAC3D,IAAiB,sBAAsB,CAatC;AAbD,WAAiB,sBAAsB;IACrC,sDAAsD;IACtD,SAAgB,SAAS,CAAC,IAA4B;QACpD,OAAO,mCAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9C,CAAC;IAFe,gCAAS,YAExB,CAAA;IACD,iEAAiE;IACjE,SAAgB,eAAe,CAAC,IAA4B;QAC1D,OAAO,mCAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;IAFe,sCAAe,kBAE9B,CAAA;IACD,uDAAuD;IACvD,SAAgB,cAAc,CAAC,IAA4B;QACzD,OAAO,mCAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;IAFe,qCAAc,iBAE7B,CAAA;AACH,CAAC,EAbgB,sBAAsB,sCAAtB,sBAAsB,QAatC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n * See LICENSE.md in the project root for license terms and full copyright notice.\n *--------------------------------------------------------------------------------------------*/\n\nimport { ConcatenatedValue, InstanceKey, OmitOverUnion, PrimitiveValue } from \"@itwin/presentation-shared\";\nimport { GroupingHierarchyNode, NonGroupingHierarchyNode } from \"../HierarchyNode\";\nimport { GenericNodeKey, HierarchyNodeKey, InstancesNodeKey } from \"../HierarchyNodeKey\";\n\n/**\n * Base processing parameters that apply to every node.\n * @beta\n */\ninterface HierarchyNodeProcessingParamsBase {\n  /** Indicates if this node should be hidden if it has no child nodes. */\n  hideIfNoChildren?: boolean;\n  /** Indicates that this node should always be hidden and its children should be loaded in its place. */\n  hideInHierarchy?: boolean;\n}\n\n/**\n * A data structure for defining nodes' grouping requirements.\n * @beta\n */\ninterface HierarchyNodeGroupingParams {\n  byLabel?: HierarchyNodeLabelGroupingParams;\n  byClass?: boolean | HierarchyNodeGroupingParamsBase;\n  byBaseClasses?: HierarchyNodeBaseClassGroupingParams;\n  byProperties?: HierarchyNodePropertiesGroupingParams;\n}\n\n/**\n * A data structure for defining params specifically used for label grouping.\n * @beta\n */\ninterface HierarchyNodeLabelGroupingBaseParams {\n  /** Label grouping option that determines whether to group nodes or to merge them. Defaults to \"group\".*/\n  action?: \"group\" | \"merge\";\n  /** Value that needs to match in order for nodes to be grouped or merged.*/\n  groupId?: string;\n}\n\n/**\n * A data structure for defining label merging.\n * @beta\n */\ninterface HierarchyNodeLabelGroupingMergeParams extends HierarchyNodeLabelGroupingBaseParams {\n  action: \"merge\";\n}\n\n/**\n * A data structure for defining label grouping with additional parameters.\n * @beta\n */\ninterface HierarchyNodeLabelGroupingGroupParams extends HierarchyNodeLabelGroupingBaseParams, HierarchyNodeGroupingParamsBase {\n  action?: \"group\";\n}\n\n/**\n * A data structure for defining possible label grouping types.\n * @beta\n */\nexport type HierarchyNodeLabelGroupingParams = boolean | HierarchyNodeLabelGroupingMergeParams | HierarchyNodeLabelGroupingGroupParams;\n\n/**\n * Grouping parameters that are shared across all types of groupings.\n * @beta\n */\nexport interface HierarchyNodeGroupingParamsBase {\n  /** Hiding option that determines whether to hide group nodes which have no siblings at the same hierarchy level. */\n  hideIfNoSiblings?: boolean;\n  /** Hiding option that determines whether to hide group nodes which have only one node as its children. */\n  hideIfOneGroupedNode?: boolean;\n  /** Option which auto expands grouping nodes' children when it has single child or always. */\n  autoExpand?: HierarchyNodeAutoExpandProp;\n}\n\n/**\n * Defines possible values for `BaseGroupingParams.autoExpand` attribute:\n * - `single-child` - set the grouping node to auto-expand if it groups a single node.\n * - `always` - always set the grouping node to auto-expand.\n * @beta\n */\nexport type HierarchyNodeAutoExpandProp = \"single-child\" | \"always\";\n\n/**\n * A data structure that represents base class grouping.\n * @beta\n */\ninterface HierarchyNodeBaseClassGroupingParams extends HierarchyNodeGroupingParamsBase {\n  /**\n   * Full names of classes, which should be used to group the node. Only has effect if the node\n   * represents an instance of that class.\n   *\n   * Full class name format: `SchemaName.ClassName`.\n   */\n  fullClassNames: string[];\n}\n\n/**\n * A data structure that represents properties grouping.\n * @beta\n */\nexport interface HierarchyNodePropertiesGroupingParams extends HierarchyNodeGroupingParamsBase {\n  /**\n   * Full name of a class whose properties are used to group the node. Only has effect if the node\n   * represents an instance of that class.\n   *\n   * Full class name format: `SchemaName.ClassName`.\n   */\n  propertiesClassName: string;\n  /**\n   * Property grouping option that determines whether to group nodes whose grouping value is not set or is set to an empty string.\n   *\n   * Label of the created grouping node will be `Not Specified`.\n   */\n  createGroupForUnspecifiedValues?: boolean;\n  /**\n   * Property grouping option that determines whether to group nodes whose grouping value doesn't fit within any of the provided\n   * ranges, or is not a numeric value.\n   *\n   * Label of the created grouping node will be `Other`.\n   */\n  createGroupForOutOfRangeValues?: boolean;\n  /**\n   * Properties of the specified class, by which the nodes should be grouped. Each provided group definition results in a\n   * grouping hierarchy level.\n   *\n   * Example usage:\n   * ```ts\n   * propertyGroups: [\n   *   {\n   *     propertyName: \"type\",\n   *     propertyValue: \"Wall\"\n   *   },\n   *   {\n   *     propertyName: \"length\",\n   *     propertyValue: 15,\n   *     ranges: [\n   *       { fromValue: 1, toValue: 10, rangeLabel: \"Small\" },\n   *       { fromValue: 11, toValue: 20, rangeLabel: \"Medium\" }\n   *     ]\n   *   },\n   * ]\n   * ```\n   */\n  propertyGroups: HierarchyNodePropertyGroup[];\n}\n\n/**\n * A data structure that represents specific properties' grouping params.\n * @beta\n */\nexport interface HierarchyNodePropertyGroup {\n  /** A string indicating the name of the property to group by. */\n  propertyName: string;\n  /**  Value of the property, which will be used to group the node. */\n  propertyValue?: PrimitiveValue | ConcatenatedValue;\n  /** Ranges are used to group nodes by numeric properties which are within specified bounds. */\n  ranges?: HierarchyNodePropertyValueRange[];\n}\n\n/**\n * A data structure that represents boundaries for a value.\n * @beta\n */\nexport interface HierarchyNodePropertyValueRange {\n  /** Defines the lower bound of the range. */\n  fromValue: number;\n  /** Defines the upper bound of the range. */\n  toValue: number;\n  /** Defines the range label. Will be used as `PropertyValueRangeGroupingNode` node's display label. */\n  rangeLabel?: string;\n}\n\n/**\n * Processing parameters that apply to instance nodes.\n * @beta\n */\nexport interface InstanceHierarchyNodeProcessingParams extends HierarchyNodeProcessingParamsBase {\n  grouping?: HierarchyNodeGroupingParams;\n}\n\n/**\n * A generic (not based on data in an iModel) node that has processing parameters.\n * @beta\n */\nexport type ProcessedGenericHierarchyNode = Omit<NonGroupingHierarchyNode, \"key\" | \"children\"> & {\n  key: GenericNodeKey;\n  children?: boolean;\n  processingParams?: HierarchyNodeProcessingParamsBase;\n};\n\n/**\n * An instances' (based on data in an iModel) node that has processing parameters.\n * @beta\n */\nexport type ProcessedInstanceHierarchyNode = Omit<NonGroupingHierarchyNode, \"key\" | \"children\"> & {\n  key: InstancesNodeKey;\n  children?: boolean;\n  processingParams?: InstanceHierarchyNodeProcessingParams;\n};\n\n/**\n * A grouping node that groups either instance nodes or other grouping nodes.\n * @beta\n */\nexport type ProcessedGroupingHierarchyNode = Omit<GroupingHierarchyNode, \"children\"> & {\n  children: Array<ProcessedGroupingHierarchyNode | ProcessedInstanceHierarchyNode>;\n};\n\n/**\n * A `HierarchyNode` that may have processing parameters defining whether it should be hidden under some conditions,\n * how it should be grouped, sorted, etc.\n *\n * Type guards under `HierarchyNode` namespace can be used to differentiate between different sub-types of\n * `ProcessedHierarchyNode`.\n *\n * @beta\n */\nexport type ProcessedHierarchyNode = ProcessedGenericHierarchyNode | ProcessedInstanceHierarchyNode | ProcessedGroupingHierarchyNode;\n\n/** @beta */\n// eslint-disable-next-line @typescript-eslint/no-redeclare\nexport namespace ProcessedHierarchyNode {\n  /** Checks whether the given node is a generic node */\n  export function isGeneric(node: ProcessedHierarchyNode): node is ProcessedGenericHierarchyNode {\n    return HierarchyNodeKey.isGeneric(node.key);\n  }\n  /** Checks whether the given node is an ECInstances-based node */\n  export function isInstancesNode(node: ProcessedHierarchyNode): node is ProcessedInstanceHierarchyNode {\n    return HierarchyNodeKey.isInstances(node.key);\n  }\n  /** Checks whether the given node is a grouping node */\n  export function isGroupingNode(node: ProcessedHierarchyNode): node is ProcessedGroupingHierarchyNode {\n    return HierarchyNodeKey.isGrouping(node.key);\n  }\n}\n\n/**\n * A `ProcessedHierarchyNode` that has an unformatted label in a form of `ConcatenatedValue`. Generally this is\n * returned by hierarchy definitions as a generic node or when the node is just parsed from query results.\n * @beta\n */\nexport type SourceHierarchyNode<TBase = SourceGenericHierarchyNode | SourceInstanceHierarchyNode> = OmitOverUnion<TBase, \"label\" | \"parentKeys\"> & {\n  label: string | ConcatenatedValue;\n};\n\n/**\n * A kind of `ProcessedGenericHierarchyNode` that has unformatted label and doesn't know about its ancestors.\n * @beta\n */\nexport type SourceGenericHierarchyNode = SourceHierarchyNode<Omit<ProcessedGenericHierarchyNode, \"key\"> & { key: string }>;\n\n/**\n * A kind of `ProcessedInstanceHierarchyNode` that has unformatted label and doesn't know about its ancestors.\n * @beta\n */\nexport type SourceInstanceHierarchyNode = SourceHierarchyNode<\n  Omit<ProcessedInstanceHierarchyNode, \"key\"> & {\n    key: Omit<InstancesNodeKey, \"instanceKeys\"> & { instanceKeys: InstanceKey[] };\n  }\n>;\n"]}

package/lib/cjs/hierarchies/imodel/IModelHierarchyProvider.d.ts

@@ -0,0 +1,77 @@
+import { ECClassHierarchyInspector, ECSchemaProvider, Event, IPrimitiveValueFormatter } from "@itwin/presentation-shared";
+import { HierarchyFilteringPath } from "../HierarchyFiltering";
+import { HierarchyProvider } from "../HierarchyProvider";
+import { HierarchyDefinition } from "./IModelHierarchyDefinition";
+import { LimitingECSqlQueryExecutor } from "./LimitingECSqlQueryExecutor";
+/**
+ * Defines the strings used by hierarchy provider.
+ * @beta
+ */
+interface IModelHierarchyProviderLocalizedStrings {
+    /**
+     * A string for "Unspecified". Used for labels of property grouping nodes
+     * that group by an empty value.
+     */
+    unspecified: string;
+    /**
+     * A string for "Other". Used for label of a range property grouping node that
+     * groups values which don't fit into any other range.
+     */
+    other: string;
+}
+/** @beta */
+type IModelAccess = ECSchemaProvider & LimitingECSqlQueryExecutor & ECClassHierarchyInspector & {
+    imodelKey: string;
+};
+/**
+ * Props for `createIModelHierarchyProvider`.
+ * @beta
+ */
+interface IModelHierarchyProviderProps {
+    /**
+     * An object that provides access to iModel's data and metadata.
+     *
+     * @see `ECSchemaProvider`
+     * @see `LimitingECSqlQueryExecutor`
+     * @see `ECClassHierarchyInspector`
+     */
+    imodelAccess: IModelAccess;
+    /** An event that is raised when iModel data, that may affect the hierarchy, changes. */
+    imodelChanged?: Event<() => void>;
+    /**
+     * A function that returns a hierarchy definition, describing how the hierarchy that the provider should be create. The
+     * function is called once during the provider's construction.
+     */
+    hierarchyDefinition: HierarchyDefinition;
+    /** Maximum number of queries that the provider attempts to execute in parallel. Defaults to `10`. */
+    queryConcurrency?: number;
+    /**
+     * The amount of queries whose results are stored in-memory for quick retrieval. Defaults to `1`,
+     * which means only results of the last run query are cached.
+     */
+    queryCacheSize?: number;
+    /** A set of localized strings to use. Defaults to English strings. */
+    localizedStrings?: Partial<IModelHierarchyProviderLocalizedStrings>;
+    /**
+     * A values formatter for formatting node labels. Defaults to the
+     * result of `createDefaultValueFormatter` called with default parameters. May be overridden
+     * by calling `setFormatter` on the provider instance.
+     */
+    formatter?: IPrimitiveValueFormatter;
+    /** Props for filtering the hierarchy. */
+    filtering?: {
+        /** A list of node identifiers from root to target node. */
+        paths: HierarchyFilteringPath[];
+    };
+}
+/**
+ * Creates an instance of `HierarchyProvider` that creates a hierarchy based on given iModel and
+ * a hierarchy definition, which defines each hierarchy level through ECSQL queries.
+ *
+ * @beta
+ */
+export declare function createIModelHierarchyProvider(props: IModelHierarchyProviderProps): HierarchyProvider & {
+    dispose: () => void;
+};
+export {};
+//# sourceMappingURL=IModelHierarchyProvider.d.ts.map

package/lib/cjs/hierarchies/imodel/IModelHierarchyProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IModelHierarchyProvider.d.ts","sourceRoot":"","sources":["../../../../src/hierarchies/imodel/IModelHierarchyProvider.ts"],"names":[],"mappings":"AAyBA,OAAO,EAGL,yBAAyB,EACzB,gBAAgB,EAGhB,KAAK,EAGL,wBAAwB,EAEzB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAG/D,OAAO,EAA0B,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAiBjF,OAAO,EAA6B,mBAAmB,EAA4B,MAAM,6BAA6B,CAAC;AASvH,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAe1E;;;GAGG;AACH,UAAU,uCAAuC;IAC/C;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,YAAY;AACZ,KAAK,YAAY,GAAG,gBAAgB,GAAG,0BAA0B,GAAG,yBAAyB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtH;;;GAGG;AACH,UAAU,4BAA4B;IACpC;;;;;;OAMG;IACH,YAAY,EAAE,YAAY,CAAC;IAE3B,wFAAwF;IACxF,aAAa,CAAC,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAElC;;;OAGG;IACH,mBAAmB,EAAE,mBAAmB,CAAC;IAEzC,qGAAqG;IACrG,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,sEAAsE;IACtE,gBAAgB,CAAC,EAAE,OAAO,CAAC,uCAAuC,CAAC,CAAC;IAEpE;;;;OAIG;IACH,SAAS,CAAC,EAAE,wBAAwB,CAAC;IACrC,yCAAyC;IACzC,SAAS,CAAC,EAAE;QACV,2DAA2D;QAC3D,KAAK,EAAE,sBAAsB,EAAE,CAAC;KACjC,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,4BAA4B,GAAG,iBAAiB,GAAG;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CAE9H"}