@itwin/tree-widget-react 2.3.0 → 3.0.0-dev.0

package/lib/esm/components/trees/stateless/imodel-content-tree/IModelContentTreeDefinition.js

@@ -0,0 +1,635 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import { createClassBasedHierarchyDefinition, createNodesQueryClauseFactory, HierarchyNode, NodeSelectClauseColumnNames, } from "@itwin/presentation-hierarchies";
+import { createBisInstanceLabelSelectClauseFactory, ECSql } from "@itwin/presentation-shared";
+import { createIdsSelector } from "../common/Utils";
+export class IModelContentTreeDefinition {
+    constructor(props) {
+        this._impl = createClassBasedHierarchyDefinition({
+            classHierarchyInspector: props.imodelAccess,
+            hierarchy: {
+                rootNodes: async (requestProps) => this.createRootHierarchyLevelDefinition(requestProps),
+                childNodes: [
+                    {
+                        parentNodeClassName: "BisCore.Subject",
+                        definitions: async (requestProps) => this.createSubjectChildrenQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.ISubModeledElement",
+                        definitions: async (requestProps) => this.createISubModeledElementChildrenQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.GeometricModel3d",
+                        definitions: async (requestProps) => this.createGeometricModelChildrenQuery({ ...requestProps, viewType: "3d" }),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.GeometricModel2d",
+                        definitions: async (requestProps) => this.createGeometricModelChildrenQuery({ ...requestProps, viewType: "2d" }),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.SpatialCategory",
+                        definitions: async (requestProps) => this.createCategoryChildrenQuery({ ...requestProps, viewType: "3d" }),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.DrawingCategory",
+                        definitions: async (requestProps) => this.createCategoryChildrenQuery({ ...requestProps, viewType: "2d" }),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.Model",
+                        definitions: async (requestProps) => this.createModelChildrenQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.GroupInformationElement",
+                        definitions: async (requestProps) => this.createGroupInformationElementChildElementsQuery(requestProps),
+                    },
+                    {
+                        customParentNodeKey: "ChildrenNode",
+                        definitions: async (requestProps) => this.createChildrenNodeChildrenQuery(requestProps),
+                    },
+                    {
+                        customParentNodeKey: "MembersNode",
+                        definitions: async (requestProps) => this.createGroupInformationElementMemberElementsQuery(requestProps),
+                    },
+                    {
+                        parentNodeClassName: "BisCore.Element",
+                        definitions: async (requestProps) => this.createElementChildrenQuery(requestProps),
+                    },
+                ],
+            },
+        });
+        this._selectQueryFactory = createNodesQueryClauseFactory({ imodelAccess: props.imodelAccess });
+        this._nodeLabelSelectClauseFactory = createBisInstanceLabelSelectClauseFactory({ classHierarchyInspector: props.imodelAccess });
+    }
+    async postProcessNode(node) {
+        if (HierarchyNode.isClassGroupingNode(node)) {
+            const label = node.children.length ? `${node.label} (${node.children.length})` : node.label;
+            return { ...node, label, extendedData: { ...node.extendedData, imageId: "icon-ec-class" } };
+        }
+        return node;
+    }
+    async defineHierarchyLevel(props) {
+        return this._impl.defineHierarchyLevel(props);
+    }
+    async createRootHierarchyLevelDefinition(props) {
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: props.instanceFilter,
+            contentClass: { fullName: "BisCore.Subject", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: "BisCore.Subject",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: ECSql.createRawPropertyValueSelector("this", "ECClassId") },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.Subject",
+                            }),
+                        },
+                        extendedData: {
+                            imageId: "icon-imodel-hollow-2",
+                            isSubject: true,
+                        },
+                        autoExpand: true,
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            ${instanceFilterClauses.joins}
+            WHERE
+              this.Parent IS NULL
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                },
+            },
+        ];
+    }
+    async createSubjectChildrenQuery({ parentNodeInstanceIds: subjectIds, instanceFilter, }) {
+        const selectColumnNames = Object.values(NodeSelectClauseColumnNames).join(", ");
+        const subjectFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.Subject", alias: "this" },
+        });
+        const modelFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.Model", alias: "this" },
+        });
+        const ctes = [
+            `
+        subjects(${selectColumnNames}, ParentId) AS (
+          SELECT
+            ${await this._selectQueryFactory.createSelectClause({
+                ecClassId: { selector: "this.ECClassId" },
+                ecInstanceId: { selector: "this.ECInstanceId" },
+                nodeLabel: {
+                    selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                        classAlias: "this",
+                        className: "BisCore.Subject",
+                    }),
+                },
+                hideNodeInHierarchy: {
+                    selector: `
+                  CASE
+                    WHEN (
+                      json_extract(this.JsonProperties, '$.Subject.Job.Bridge') IS NOT NULL
+                      OR json_extract(this.JsonProperties, '$.Subject.Model.Type') = 'Hierarchy'
+                    ) THEN 1
+                    ELSE 0
+                  END
+                `,
+                },
+                extendedData: {
+                    imageId: "icon-folder",
+                    isSubject: true,
+                },
+                supportsFiltering: true,
+            })},
+            this.Parent.Id
+          FROM BisCore.Subject this
+        )
+      `,
+            `
+        child_subjects(${selectColumnNames}, ParentId, RootId) AS (
+          SELECT *, s.ParentId RootId FROM subjects s
+          UNION ALL
+          SELECT s.*, p.RootId
+          FROM child_subjects p
+          JOIN subjects s ON s.ParentId = p.ECInstanceId
+          WHERE p.${NodeSelectClauseColumnNames.HideNodeInHierarchy} = 1
+        )
+      `,
+        ];
+        return [
+            {
+                fullClassName: "BisCore.Subject",
+                query: {
+                    ctes,
+                    ecsql: `
+            SELECT
+              ${Object.values(NodeSelectClauseColumnNames)
+                        .map((name) => `cs.${name} AS ${name}`)
+                        .join(", ")},
+              ParentId
+            FROM child_subjects cs
+            JOIN ${subjectFilterClauses.from} this ON this.ECInstanceId = cs.ECInstanceId
+            ${subjectFilterClauses.joins}
+            WHERE
+              cs.RootId IN (${subjectIds.map(() => "?").join(",")})
+              AND NOT cs.${NodeSelectClauseColumnNames.HideNodeInHierarchy}
+              ${subjectFilterClauses.where ? `AND ${subjectFilterClauses.where}` : ""}
+          `,
+                    bindings: [...subjectIds.map((id) => ({ type: "id", value: id }))],
+                },
+            },
+            {
+                fullClassName: "BisCore.Model",
+                query: {
+                    ctes,
+                    ecsql: `
+            SELECT childModel.ECInstanceId AS ECInstanceId, childModel.*
+            FROM (
+              SELECT
+                ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "model.ECClassId" },
+                        ecInstanceId: { selector: "model.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "partition",
+                                className: "BisCore.InformationPartitionElement",
+                            }),
+                        },
+                        hideNodeInHierarchy: {
+                            selector: `
+                      CASE
+                        WHEN (
+                          json_extract([partition].JsonProperties, '$.PhysicalPartition.Model.Content') IS NOT NULL
+                          OR json_extract([partition].JsonProperties, '$.GraphicalPartition3d.Model.Content') IS NOT NULL
+                        ) THEN 1
+                        ELSE 0
+                      END
+                    `,
+                        },
+                        extendedData: {
+                            imageId: "icon-model",
+                        },
+                        supportsFiltering: true,
+                    })}
+              FROM BisCore.Model model
+              JOIN bis.InformationPartitionElement [partition] ON [partition].ECInstanceId = model.ModeledElement.Id
+              JOIN bis.Subject [subject] ON [subject].ECInstanceId = [partition].Parent.Id OR json_extract([subject].JsonProperties,'$.Subject.Model.TargetPartition') = printf('0x%x', [partition].ECInstanceId)
+              WHERE
+                NOT model.IsPrivate
+                AND (
+                  [subject].ECInstanceId IN (${subjectIds.map(() => "?").join(",")})
+                  OR [subject].ECInstanceId IN (
+                    SELECT s.ECInstanceId
+                    FROM child_subjects s
+                    WHERE s.RootId IN (${subjectIds.map(() => "?").join(",")}) AND s.${NodeSelectClauseColumnNames.HideNodeInHierarchy}
+                  )
+                )
+            ) childModel
+            JOIN ${modelFilterClauses.from} this ON this.ECInstanceId = childModel.ECInstanceId
+            ${modelFilterClauses.joins}
+            ${modelFilterClauses.where ? `AND (childModel.${NodeSelectClauseColumnNames.HideNodeInHierarchy} OR ${modelFilterClauses.where})` : ""}
+          `,
+                    bindings: [
+                        ...subjectIds.map((id) => ({ type: "id", value: id })),
+                        ...subjectIds.map((id) => ({ type: "id", value: id })),
+                    ],
+                },
+            },
+        ];
+    }
+    async createISubModeledElementChildrenQuery({ parentNodeInstanceIds: elementIds, }) {
+        // note: we do not apply hierarchy level filtering on this hierarchy level, because it's always
+        // hidden - the filter will get applied on the child hierarchy levels
+        return [
+            {
+                fullClassName: "BisCore.Model",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: "",
+                        hideNodeInHierarchy: true,
+                    })}
+            FROM BisCore.Model this
+            WHERE
+              this.ModeledElement.Id IN (${elementIds.map(() => "?").join(",")})
+              AND NOT this.IsPrivate
+          `,
+                    bindings: [...elementIds.map((id) => ({ type: "id", value: id }))],
+                },
+            },
+        ];
+    }
+    async createGeometricModelChildrenQuery({ parentNodeInstanceIds: modelIds, instanceFilter, viewType, }) {
+        const { categoryClass, elementClass } = getClassNameByViewType(viewType);
+        const categoryFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: categoryClass, alias: "this" },
+        });
+        const informationContentElementFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.InformationContentElement", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: categoryClass,
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: categoryClass,
+                            }),
+                        },
+                        hasChildren: true,
+                        grouping: { byLabel: { action: "merge", groupId: "category" } },
+                        extendedData: {
+                            imageId: "icon-layers",
+                            modelIds: { selector: createIdsSelector(modelIds) },
+                            isCategory: true,
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${categoryFilterClauses.from} this
+            JOIN ${elementClass} e ON e.Category.Id = this.ECInstanceId
+            ${categoryFilterClauses.joins}
+            WHERE
+              e.Model.Id IN (${modelIds.map(() => "?").join(",")})
+              ${categoryFilterClauses.where ? `AND ${categoryFilterClauses.where}` : ""}
+          `,
+                    bindings: modelIds.map((id) => ({ type: "id", value: id })),
+                },
+            },
+            {
+                fullClassName: "BisCore.InformationContentElement",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.InformationContentElement",
+                            }),
+                        },
+                        extendedData: {
+                            isInformationElement: true,
+                        },
+                        hasChildren: true,
+                        grouping: {
+                            byClass: true,
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${informationContentElementFilterClauses.from} this
+            ${informationContentElementFilterClauses.joins}
+            WHERE
+              this.Model.Id IN (${modelIds.map(() => "?").join(",")})
+              ${informationContentElementFilterClauses.where ? `AND ${informationContentElementFilterClauses.where}` : ""}
+          `,
+                    bindings: modelIds.map((id) => ({ type: "id", value: id })),
+                },
+            },
+        ];
+    }
+    async createCategoryChildrenQuery({ parentNodeInstanceIds: categoryIds, parentNode, instanceFilter, viewType, }) {
+        // We only want to handle a category added as a child of `GeometricModel2d` or `GeometricModel3d`.
+        if (!parentNode.extendedData?.isCategory) {
+            return [];
+        }
+        const { elementClass, modelClass } = getClassNameByViewType(viewType);
+        const modelIds = parentNode.extendedData && parentNode.extendedData.hasOwnProperty("modelIds") && Array.isArray(parentNode.extendedData.modelIds)
+            ? parentNode.extendedData.modelIds.reduce((arr, ids) => [...arr, ...(Array.isArray(ids) ? ids : [ids])], new Array())
+            : [];
+        if (modelIds.length === 0) {
+            throw new Error(`Invalid category node "${parentNode.label}" - missing model information.`);
+        }
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: elementClass, alias: "this" },
+        });
+        return [
+            {
+                fullClassName: elementClass,
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: elementClass,
+                            }),
+                        },
+                        hasChildren: {
+                            selector: `
+                    IFNULL((
+                      SELECT 1
+                      FROM (
+                        SELECT Parent.Id ParentId FROM ${elementClass}
+                        UNION ALL
+                        SELECT ModeledElement.Id ParentId FROM ${modelClass}
+                      )
+                      WHERE ParentId = this.ECInstanceId
+                      LIMIT 1
+                    ), 0)
+                  `,
+                        },
+                        grouping: {
+                            byClass: true,
+                        },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            ${instanceFilterClauses.joins}
+            WHERE
+              this.Category.Id IN (${categoryIds.map(() => "?").join(",")})
+              AND this.Model.Id IN (${modelIds.map(() => "?").join(",")})
+              AND this.Parent IS NULL
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                    bindings: [...categoryIds.map((id) => ({ type: "id", value: id })), ...modelIds.map((id) => ({ type: "id", value: id }))],
+                },
+            },
+        ];
+    }
+    async createModelChildrenQuery({ parentNodeInstanceIds: modelIds, instanceFilter, }) {
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.Element", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: "BisCore.Element",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.Element",
+                            }),
+                        },
+                        hasChildren: {
+                            selector: `
+                    IFNULL((
+                      SELECT 1
+                      FROM (
+                        SELECT Parent.Id ParentId FROM BisCore.Element
+                        UNION ALL
+                        SELECT ModeledElement.Id ParentId FROM BisCore.Model
+                      )
+                      WHERE ParentId = this.ECInstanceId
+                      LIMIT 1
+                    ), 0)
+                  `,
+                        },
+                        grouping: {
+                            byClass: true,
+                        },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            JOIN BisCore.Model m ON m.ECInstanceId = this.Model.id
+            ${instanceFilterClauses.joins}
+            WHERE
+              m.ECClassId IS NOT (BisCore.GeometricModel) AND
+              this.Parent IS NULL AND this.Model.Id IN (${modelIds.map(() => "?").join(",")})
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                    bindings: modelIds.map((id) => ({ type: "id", value: id })),
+                },
+            },
+        ];
+    }
+    async createGroupInformationElementChildElementsQuery({ parentNodeInstanceIds: groupIds, }) {
+        return [
+            {
+                node: {
+                    key: "ChildrenNode",
+                    label: "Children",
+                    extendedData: {
+                        groupIds,
+                        imageId: "icon-hierarchy-tree",
+                    },
+                    supportsFiltering: true,
+                    processingParams: {
+                        hideIfNoChildren: true,
+                    },
+                },
+            },
+            {
+                node: {
+                    key: "MembersNode",
+                    label: "Members",
+                    extendedData: {
+                        groupIds,
+                        imageId: "icon-group",
+                    },
+                    supportsFiltering: true,
+                    processingParams: {
+                        hideIfNoChildren: true,
+                    },
+                },
+            },
+        ];
+    }
+    async createChildrenNodeChildrenQuery({ parentNode, instanceFilter }) {
+        const groupIds = parentNode.extendedData?.groupIds;
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.Element", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: "BisCore.Element",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.Element",
+                            }),
+                        },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        grouping: { byClass: true },
+                        hasChildren: false,
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            ${instanceFilterClauses.joins}
+            WHERE
+              this.Parent.Id IN (${groupIds.map(() => "?").join(",")})
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                    bindings: groupIds.map((id) => ({ type: "id", value: id })),
+                },
+            },
+        ];
+    }
+    async createGroupInformationElementMemberElementsQuery({ parentNode, instanceFilter, }) {
+        const groupIds = parentNode.extendedData?.groupIds;
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.Element", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: "BisCore.Element",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.Element",
+                            }),
+                        },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        hasChildren: false,
+                        grouping: { byClass: true },
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            JOIN BisCore.ElementGroupsMembers egm ON egm.TargetECInstanceId = this.ECInstanceId
+            ${instanceFilterClauses.joins}
+            WHERE
+              egm.SourceECInstanceId IN (${groupIds.map(() => "?").join(",")})
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                    bindings: groupIds.map((id) => ({ type: "id", value: id })),
+                },
+            },
+        ];
+    }
+    async createElementChildrenQuery({ parentNodeInstanceIds: elementIds, instanceFilter, parentNode, }) {
+        const data = parentNode.extendedData;
+        if (data?.isCategory || data?.isSubject || data?.isInformationElement) {
+            return [];
+        }
+        const instanceFilterClauses = await this._selectQueryFactory.createFilterClauses({
+            filter: instanceFilter,
+            contentClass: { fullName: "BisCore.Element", alias: "this" },
+        });
+        return [
+            {
+                fullClassName: "BisCore.Element",
+                query: {
+                    ecsql: `
+            SELECT
+              ${await this._selectQueryFactory.createSelectClause({
+                        ecClassId: { selector: "this.ECClassId" },
+                        ecInstanceId: { selector: "this.ECInstanceId" },
+                        nodeLabel: {
+                            selector: await this._nodeLabelSelectClauseFactory.createSelectClause({
+                                classAlias: "this",
+                                className: "BisCore.Element",
+                            }),
+                        },
+                        grouping: {
+                            byClass: true,
+                        },
+                        extendedData: {
+                            imageId: "icon-item",
+                        },
+                        supportsFiltering: true,
+                    })}
+            FROM ${instanceFilterClauses.from} this
+            JOIN BisCore.Element p ON p.ECInstanceId = this.Parent.Id
+            ${instanceFilterClauses.joins}
+            WHERE
+              p.ECInstanceId IN (${elementIds.map(() => "?").join(",")}) AND
+              p.ECClassId IS NOT (BisCore.ISubModeledElement)
+              ${instanceFilterClauses.where ? `AND ${instanceFilterClauses.where}` : ""}
+          `,
+                    bindings: elementIds.map((id) => ({ type: "id", value: id })),
+                },
+            },
+        ];
+    }
+}
+function getClassNameByViewType(view) {
+    if (view === "2d") {
+        return { categoryClass: "BisCore.DrawingCategory", elementClass: "BisCore.GeometricElement2d", modelClass: "BisCore.GeometricModel2d" };
+    }
+    return { categoryClass: "BisCore.SpatialCategory", elementClass: "BisCore.GeometricElement3d", modelClass: "BisCore.GeometricModel3d" };
+}
+//# sourceMappingURL=IModelContentTreeDefinition.js.map