@itwin/hypermodeling-frontend 4.0.0-dev.52 → 4.0.0-dev.55

package/lib/esm/SectionGraphicsProvider.js

@@ -1,269 +1,269 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module HyperModeling
- */
-import { assert, compareBooleans, compareStrings, Id64 } from "@itwin/core-bentley";
-import { ClipShape, ClipVector, Point3d, Transform } from "@itwin/core-geometry";
-import { ColorDef, Placement2d } from "@itwin/core-common";
-import { CategorySelectorState, DisplayStyle2dState, DrawingViewState, FeatureSymbology, GeometricModel2dState, GraphicBranch, IModelApp, SheetModelState, Tile, TileDrawArgs, TileLoadPriority, TileTree, TileTreeReference, } from "@itwin/core-frontend";
-import { HyperModeling } from "./HyperModeling";
-class ProxyTreeSupplier {
-    compareTileTreeIds(lhs, rhs) {
-        let cmp = compareBooleans(lhs.isSheet, rhs.isSheet);
-        if (0 === cmp)
-            cmp = compareStrings(lhs.state.id, rhs.state.id);
-        return cmp;
-    }
-    async createTileTree(id, iModel) {
-        let view;
-        if (id.isSheet) {
-            assert(undefined !== id.attachment);
-            view = await this.createSheetViewState(id.state, id.attachment);
-        }
-        else {
-            view = await id.state.tryLoadDrawingView();
-        }
-        if (undefined === view)
-            return undefined;
-        try {
-            await iModel.models.load(view.baseModelId);
-            const model = iModel.models.getLoaded(view.baseModelId);
-            if (undefined === model || !(model instanceof GeometricModel2dState))
-                return undefined;
-            const treeRef = model.createTileTreeReference(view);
-            const tree = await treeRef.treeOwner.loadTree();
-            if (undefined === tree)
-                return undefined;
-            const ctor = id.isSheet ? SheetProxyTree : DrawingProxyTree;
-            return new ctor({ tree, ref: treeRef, view, state: id.state, attachment: id.attachment });
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async createSheetViewState(state, attachment) {
-        assert(undefined !== state.viewAttachment);
-        try {
-            // A persistent view of the sheet doesn't necessarily exist, and we don't want a SheetViewState anyway.
-            // All we want is to draw all the elements in the sheet (sans view attachments) clipped by the drawing boundary.
-            // However, ModelState.createTileTreeReference() requires a ViewState.
-            await state.iModel.models.load(attachment.model);
-            const sheet = state.iModel.models.getLoaded(attachment.model);
-            if (undefined === sheet || !(sheet instanceof SheetModelState))
-                return undefined;
-            const sheetExtents = await sheet.queryModelRange();
-            const viewProps = {
-                baseModelId: attachment.model,
-                origin: { x: 0, y: 0 },
-                delta: { x: sheetExtents.high.x, y: sheetExtents.high.y },
-                angle: 0,
-                categorySelectorId: Id64.invalid,
-                displayStyleId: Id64.invalid,
-                model: Id64.invalid,
-                code: {
-                    spec: Id64.invalid,
-                    scope: Id64.invalid,
-                },
-                classFullName: DrawingViewState.classFullName,
-            };
-            const displayStyle = new DisplayStyle2dState({}, state.iModel);
-            const categorySelector = new CategorySelectorState({}, state.iModel);
-            return new DrawingViewState(viewProps, state.iModel, categorySelector, displayStyle, sheetExtents);
-        }
-        catch {
-            return undefined;
-        }
-    }
-}
-const proxyTreeSupplier = new ProxyTreeSupplier();
-/** A proxy for a 2d tile tree to be drawn in the context of a spatial view. */
-class ProxyTreeReference extends TileTreeReference {
-    constructor(id) {
-        super();
-        this._owner = id.state.iModel.tiles.getTileTreeOwner(id, proxyTreeSupplier);
-    }
-    get castsShadows() {
-        return false;
-    }
-    getClipVolume(tree) {
-        return true !== HyperModeling.graphicsConfig.ignoreClip ? super.getClipVolume(tree) : undefined;
-    }
-    get treeOwner() { return this._owner; }
-    get _proxiedRef() {
-        const proxiedTree = this.treeOwner.tileTree;
-        return undefined !== proxiedTree ? proxiedTree.ref : undefined;
-    }
-    discloseTileTrees(trees) {
-        super.discloseTileTrees(trees);
-        const ref = this._proxiedRef;
-        if (undefined !== ref)
-            ref.discloseTileTrees(trees);
-    }
-    async getToolTip(hit) {
-        const ref = this._proxiedRef;
-        return undefined !== ref ? ref.getToolTip(hit) : super.getToolTip(hit);
-    }
-}
-/** A proxy for a 2d tile tree to be drawn in the context of a spatial view. */
-class ProxyTree extends TileTree {
-    constructor(params, location, clipVolume) {
-        const { tree, ref, view } = { ...params };
-        super({
-            id: params.state.id,
-            modelId: tree.modelId,
-            iModel: tree.iModel,
-            location,
-            priority: TileLoadPriority.Primary,
-            clipVolume,
-        });
-        this.tree = tree;
-        this.ref = ref;
-        this.symbologyOverrides = new FeatureSymbology.Overrides(view);
-        const range = tree.iModelTransform.multiplyRange(tree.rootTile.range);
-        const inverse = location.inverse();
-        if (undefined !== inverse)
-            inverse.multiplyRange(range, range);
-        this._viewFlagOverrides = {
-            ...view.viewFlags,
-            lighting: false,
-            // View clip (section clip) should not apply to 2d graphics.
-            clipVolume: false,
-        };
-        this._rootTile = new ProxyTile(this, range);
-    }
-    get rootTile() { return this._rootTile; }
-    get viewFlagOverrides() { return this._viewFlagOverrides; }
-    get is3d() { return false; }
-    get isContentUnbounded() { return false; }
-    get maxDepth() { return 1; }
-    draw(args) {
-        if (!this.isDisplayed)
-            return;
-        const tiles = this.selectTiles(args);
-        for (const tile of tiles)
-            tile.drawGraphics(args);
-        args.drawGraphics();
-    }
-    _selectTiles(_args) {
-        return this.isDisplayed ? [this.rootTile] : [];
-    }
-    prune() {
-        // Our single tile is only a proxy. Our proxied tree(s) will be pruned separately
-    }
-}
-class DrawingProxyTree extends ProxyTree {
-    constructor(params) {
-        const { state, attachment } = { ...params };
-        const location = state.drawingToSpatialTransform.clone();
-        let clipVolume;
-        if (attachment) {
-            assert(undefined !== state.viewAttachment);
-            const clipJSON = attachment.jsonProperties?.clip;
-            const clip = clipJSON ? ClipVector.fromJSON(clipJSON) : ClipVector.createEmpty();
-            if (!clipJSON) {
-                const placement = Placement2d.fromJSON(attachment.placement);
-                const range = placement.calculateRange();
-                clip.appendShape([
-                    Point3d.create(range.low.x, range.low.y),
-                    Point3d.create(range.high.x, range.low.y),
-                    Point3d.create(range.high.x, range.high.y),
-                    Point3d.create(range.low.x, range.high.y),
-                ]);
-            }
-            if (clip.isValid) {
-                const sheetToWorld = state.viewAttachment.transformToSpatial.clone();
-                clip.transformInPlace(sheetToWorld);
-                clipVolume = IModelApp.renderSystem.createClipVolume(clip);
-            }
-        }
-        super(params, location, clipVolume);
-    }
-    get isDisplayed() { return true !== HyperModeling.graphicsConfig.hideSectionGraphics; }
-}
-class SheetProxyTree extends ProxyTree {
-    constructor(params) {
-        const { state, attachment } = { ...params };
-        assert(undefined !== state.viewAttachment);
-        assert(undefined !== attachment);
-        const location = state.viewAttachment.transformToSpatial.clone();
-        let clipVolume;
-        if (state.viewAttachment.clip)
-            clipVolume = IModelApp.renderSystem.createClipVolume(state.viewAttachment.clip);
-        super(params, location, clipVolume);
-        // Our view is manufactured. It draws everything regardless of subcategory.
-        this.symbologyOverrides.ignoreSubCategory = true;
-    }
-    get isDisplayed() { return true !== HyperModeling.graphicsConfig.hideSheetAnnotations; }
-}
-/** The single Tile belonging to a ProxyTree, serving as a proxy for all of the proxied tree's tiles. */
-class ProxyTile extends Tile {
-    constructor(tree, range) {
-        super({ contentId: "", range, maximumSize: 512, isLeaf: true }, tree);
-        this.setIsReady();
-    }
-    get hasChildren() { return false; }
-    get hasGraphics() { return true; }
-    get channel() { throw new Error("Proxy tile has no content"); }
-    async requestContent(_isCanceled) { return undefined; }
-    async readContent(_data, _system, _isCanceled) { return {}; }
-    _loadChildren(_resolve, _reject) { }
-    drawGraphics(args) {
-        const proxyTree = this.tree;
-        const sectionTree = proxyTree.tree;
-        const location = proxyTree.iModelTransform.multiplyTransformTransform(sectionTree.iModelTransform);
-        const clipVolume = true === proxyTree.viewFlagOverrides.clipVolume ? proxyTree.clipVolume : undefined;
-        args = new TileDrawArgs({ context: args.context, location, tree: sectionTree, now: args.now, viewFlagOverrides: proxyTree.viewFlagOverrides, clipVolume, parentsAndChildrenExclusive: args.parentsAndChildrenExclusive, symbologyOverrides: proxyTree.symbologyOverrides });
-        sectionTree.draw(args);
-        const rangeGfx = this.getRangeGraphic(args.context);
-        if (undefined !== rangeGfx)
-            args.graphics.add(rangeGfx);
-        if (true !== HyperModeling.graphicsConfig.debugClipVolumes || undefined === proxyTree.clipVolume)
-            return;
-        const builder = args.context.createSceneGraphicBuilder();
-        builder.setSymbology(ColorDef.red, ColorDef.red, 2);
-        for (const prim of proxyTree.clipVolume.clipVector.clips) {
-            if (!(prim instanceof ClipShape))
-                continue;
-            const tf = prim.transformFromClip;
-            const pts = prim.polygon.map((pt) => tf ? tf.multiplyPoint3d(pt) : pt.clone());
-            builder.addLineString(pts);
-        }
-        const branch = new GraphicBranch();
-        branch.entries.push(builder.finish());
-        branch.setViewFlagOverrides({ clipVolume: false });
-        args.context.outputGraphic(args.context.createGraphicBranch(branch, Transform.createIdentity()));
-    }
-}
-/** Draws the 2d section graphics into the 3d view. */
-class SectionGraphicsProvider {
-    constructor(state, attachment) {
-        this._drawingRef = new ProxyTreeReference({ state, attachment, isSheet: false });
-        if (attachment)
-            this._sheetRef = new ProxyTreeReference({ state, attachment, isSheet: true });
-    }
-    forEachTileTreeRef(_viewport, func) {
-        func(this._drawingRef);
-        if (undefined !== this._sheetRef)
-            func(this._sheetRef);
-    }
-}
-/** Creates a TiledGraphicsProvider that can be associated with a [Viewport]($frontend) to display 2d section graphics and annotations in the context of a [SpatialViewState]($frontend).
- * Typically used indirectly via [[HyperModelingDecorator]].
- * @param state The section drawing location specifying which section drawing to display.
- * @returns A provider suitable for passing to [Viewport.addTiledGraphicsProvider]($frontend).
- * @see [[HyperModelingDecorator.toggleAttachment]] to activate section graphics for a given [[SectionMarker]].
- * @public
- */
-export async function createSectionGraphicsProvider(state) {
-    let attachment;
-    if (undefined !== state.viewAttachment) {
-        const attachments = await state.iModel.elements.getProps(state.viewAttachment.id);
-        if (1 === attachments.length)
-            attachment = attachments[0];
-    }
-    return new SectionGraphicsProvider(state, attachment);
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module HyperModeling
+ */
+import { assert, compareBooleans, compareStrings, Id64 } from "@itwin/core-bentley";
+import { ClipShape, ClipVector, Point3d, Transform } from "@itwin/core-geometry";
+import { ColorDef, Placement2d } from "@itwin/core-common";
+import { CategorySelectorState, DisplayStyle2dState, DrawingViewState, FeatureSymbology, GeometricModel2dState, GraphicBranch, IModelApp, SheetModelState, Tile, TileDrawArgs, TileLoadPriority, TileTree, TileTreeReference, } from "@itwin/core-frontend";
+import { HyperModeling } from "./HyperModeling";
+class ProxyTreeSupplier {
+    compareTileTreeIds(lhs, rhs) {
+        let cmp = compareBooleans(lhs.isSheet, rhs.isSheet);
+        if (0 === cmp)
+            cmp = compareStrings(lhs.state.id, rhs.state.id);
+        return cmp;
+    }
+    async createTileTree(id, iModel) {
+        let view;
+        if (id.isSheet) {
+            assert(undefined !== id.attachment);
+            view = await this.createSheetViewState(id.state, id.attachment);
+        }
+        else {
+            view = await id.state.tryLoadDrawingView();
+        }
+        if (undefined === view)
+            return undefined;
+        try {
+            await iModel.models.load(view.baseModelId);
+            const model = iModel.models.getLoaded(view.baseModelId);
+            if (undefined === model || !(model instanceof GeometricModel2dState))
+                return undefined;
+            const treeRef = model.createTileTreeReference(view);
+            const tree = await treeRef.treeOwner.loadTree();
+            if (undefined === tree)
+                return undefined;
+            const ctor = id.isSheet ? SheetProxyTree : DrawingProxyTree;
+            return new ctor({ tree, ref: treeRef, view, state: id.state, attachment: id.attachment });
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async createSheetViewState(state, attachment) {
+        assert(undefined !== state.viewAttachment);
+        try {
+            // A persistent view of the sheet doesn't necessarily exist, and we don't want a SheetViewState anyway.
+            // All we want is to draw all the elements in the sheet (sans view attachments) clipped by the drawing boundary.
+            // However, ModelState.createTileTreeReference() requires a ViewState.
+            await state.iModel.models.load(attachment.model);
+            const sheet = state.iModel.models.getLoaded(attachment.model);
+            if (undefined === sheet || !(sheet instanceof SheetModelState))
+                return undefined;
+            const sheetExtents = await sheet.queryModelRange();
+            const viewProps = {
+                baseModelId: attachment.model,
+                origin: { x: 0, y: 0 },
+                delta: { x: sheetExtents.high.x, y: sheetExtents.high.y },
+                angle: 0,
+                categorySelectorId: Id64.invalid,
+                displayStyleId: Id64.invalid,
+                model: Id64.invalid,
+                code: {
+                    spec: Id64.invalid,
+                    scope: Id64.invalid,
+                },
+                classFullName: DrawingViewState.classFullName,
+            };
+            const displayStyle = new DisplayStyle2dState({}, state.iModel);
+            const categorySelector = new CategorySelectorState({}, state.iModel);
+            return new DrawingViewState(viewProps, state.iModel, categorySelector, displayStyle, sheetExtents);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+const proxyTreeSupplier = new ProxyTreeSupplier();
+/** A proxy for a 2d tile tree to be drawn in the context of a spatial view. */
+class ProxyTreeReference extends TileTreeReference {
+    constructor(id) {
+        super();
+        this._owner = id.state.iModel.tiles.getTileTreeOwner(id, proxyTreeSupplier);
+    }
+    get castsShadows() {
+        return false;
+    }
+    getClipVolume(tree) {
+        return true !== HyperModeling.graphicsConfig.ignoreClip ? super.getClipVolume(tree) : undefined;
+    }
+    get treeOwner() { return this._owner; }
+    get _proxiedRef() {
+        const proxiedTree = this.treeOwner.tileTree;
+        return undefined !== proxiedTree ? proxiedTree.ref : undefined;
+    }
+    discloseTileTrees(trees) {
+        super.discloseTileTrees(trees);
+        const ref = this._proxiedRef;
+        if (undefined !== ref)
+            ref.discloseTileTrees(trees);
+    }
+    async getToolTip(hit) {
+        const ref = this._proxiedRef;
+        return undefined !== ref ? ref.getToolTip(hit) : super.getToolTip(hit);
+    }
+}
+/** A proxy for a 2d tile tree to be drawn in the context of a spatial view. */
+class ProxyTree extends TileTree {
+    constructor(params, location, clipVolume) {
+        const { tree, ref, view } = { ...params };
+        super({
+            id: params.state.id,
+            modelId: tree.modelId,
+            iModel: tree.iModel,
+            location,
+            priority: TileLoadPriority.Primary,
+            clipVolume,
+        });
+        this.tree = tree;
+        this.ref = ref;
+        this.symbologyOverrides = new FeatureSymbology.Overrides(view);
+        const range = tree.iModelTransform.multiplyRange(tree.rootTile.range);
+        const inverse = location.inverse();
+        if (undefined !== inverse)
+            inverse.multiplyRange(range, range);
+        this._viewFlagOverrides = {
+            ...view.viewFlags,
+            lighting: false,
+            // View clip (section clip) should not apply to 2d graphics.
+            clipVolume: false,
+        };
+        this._rootTile = new ProxyTile(this, range);
+    }
+    get rootTile() { return this._rootTile; }
+    get viewFlagOverrides() { return this._viewFlagOverrides; }
+    get is3d() { return false; }
+    get isContentUnbounded() { return false; }
+    get maxDepth() { return 1; }
+    draw(args) {
+        if (!this.isDisplayed)
+            return;
+        const tiles = this.selectTiles(args);
+        for (const tile of tiles)
+            tile.drawGraphics(args);
+        args.drawGraphics();
+    }
+    _selectTiles(_args) {
+        return this.isDisplayed ? [this.rootTile] : [];
+    }
+    prune() {
+        // Our single tile is only a proxy. Our proxied tree(s) will be pruned separately
+    }
+}
+class DrawingProxyTree extends ProxyTree {
+    constructor(params) {
+        const { state, attachment } = { ...params };
+        const location = state.drawingToSpatialTransform.clone();
+        let clipVolume;
+        if (attachment) {
+            assert(undefined !== state.viewAttachment);
+            const clipJSON = attachment.jsonProperties?.clip;
+            const clip = clipJSON ? ClipVector.fromJSON(clipJSON) : ClipVector.createEmpty();
+            if (!clipJSON) {
+                const placement = Placement2d.fromJSON(attachment.placement);
+                const range = placement.calculateRange();
+                clip.appendShape([
+                    Point3d.create(range.low.x, range.low.y),
+                    Point3d.create(range.high.x, range.low.y),
+                    Point3d.create(range.high.x, range.high.y),
+                    Point3d.create(range.low.x, range.high.y),
+                ]);
+            }
+            if (clip.isValid) {
+                const sheetToWorld = state.viewAttachment.transformToSpatial.clone();
+                clip.transformInPlace(sheetToWorld);
+                clipVolume = IModelApp.renderSystem.createClipVolume(clip);
+            }
+        }
+        super(params, location, clipVolume);
+    }
+    get isDisplayed() { return true !== HyperModeling.graphicsConfig.hideSectionGraphics; }
+}
+class SheetProxyTree extends ProxyTree {
+    constructor(params) {
+        const { state, attachment } = { ...params };
+        assert(undefined !== state.viewAttachment);
+        assert(undefined !== attachment);
+        const location = state.viewAttachment.transformToSpatial.clone();
+        let clipVolume;
+        if (state.viewAttachment.clip)
+            clipVolume = IModelApp.renderSystem.createClipVolume(state.viewAttachment.clip);
+        super(params, location, clipVolume);
+        // Our view is manufactured. It draws everything regardless of subcategory.
+        this.symbologyOverrides.ignoreSubCategory = true;
+    }
+    get isDisplayed() { return true !== HyperModeling.graphicsConfig.hideSheetAnnotations; }
+}
+/** The single Tile belonging to a ProxyTree, serving as a proxy for all of the proxied tree's tiles. */
+class ProxyTile extends Tile {
+    constructor(tree, range) {
+        super({ contentId: "", range, maximumSize: 512, isLeaf: true }, tree);
+        this.setIsReady();
+    }
+    get hasChildren() { return false; }
+    get hasGraphics() { return true; }
+    get channel() { throw new Error("Proxy tile has no content"); }
+    async requestContent(_isCanceled) { return undefined; }
+    async readContent(_data, _system, _isCanceled) { return {}; }
+    _loadChildren(_resolve, _reject) { }
+    drawGraphics(args) {
+        const proxyTree = this.tree;
+        const sectionTree = proxyTree.tree;
+        const location = proxyTree.iModelTransform.multiplyTransformTransform(sectionTree.iModelTransform);
+        const clipVolume = true === proxyTree.viewFlagOverrides.clipVolume ? proxyTree.clipVolume : undefined;
+        args = new TileDrawArgs({ context: args.context, location, tree: sectionTree, now: args.now, viewFlagOverrides: proxyTree.viewFlagOverrides, clipVolume, parentsAndChildrenExclusive: args.parentsAndChildrenExclusive, symbologyOverrides: proxyTree.symbologyOverrides });
+        sectionTree.draw(args);
+        const rangeGfx = this.getRangeGraphic(args.context);
+        if (undefined !== rangeGfx)
+            args.graphics.add(rangeGfx);
+        if (true !== HyperModeling.graphicsConfig.debugClipVolumes || undefined === proxyTree.clipVolume)
+            return;
+        const builder = args.context.createSceneGraphicBuilder();
+        builder.setSymbology(ColorDef.red, ColorDef.red, 2);
+        for (const prim of proxyTree.clipVolume.clipVector.clips) {
+            if (!(prim instanceof ClipShape))
+                continue;
+            const tf = prim.transformFromClip;
+            const pts = prim.polygon.map((pt) => tf ? tf.multiplyPoint3d(pt) : pt.clone());
+            builder.addLineString(pts);
+        }
+        const branch = new GraphicBranch();
+        branch.entries.push(builder.finish());
+        branch.setViewFlagOverrides({ clipVolume: false });
+        args.context.outputGraphic(args.context.createGraphicBranch(branch, Transform.createIdentity()));
+    }
+}
+/** Draws the 2d section graphics into the 3d view. */
+class SectionGraphicsProvider {
+    constructor(state, attachment) {
+        this._drawingRef = new ProxyTreeReference({ state, attachment, isSheet: false });
+        if (attachment)
+            this._sheetRef = new ProxyTreeReference({ state, attachment, isSheet: true });
+    }
+    forEachTileTreeRef(_viewport, func) {
+        func(this._drawingRef);
+        if (undefined !== this._sheetRef)
+            func(this._sheetRef);
+    }
+}
+/** Creates a TiledGraphicsProvider that can be associated with a [Viewport]($frontend) to display 2d section graphics and annotations in the context of a [SpatialViewState]($frontend).
+ * Typically used indirectly via [[HyperModelingDecorator]].
+ * @param state The section drawing location specifying which section drawing to display.
+ * @returns A provider suitable for passing to [Viewport.addTiledGraphicsProvider]($frontend).
+ * @see [[HyperModelingDecorator.toggleAttachment]] to activate section graphics for a given [[SectionMarker]].
+ * @public
+ */
+export async function createSectionGraphicsProvider(state) {
+    let attachment;
+    if (undefined !== state.viewAttachment) {
+        const attachments = await state.iModel.elements.getProps(state.viewAttachment.id);
+        if (1 === attachments.length)
+            attachment = attachments[0];
+    }
+    return new SectionGraphicsProvider(state, attachment);
+}
 //# sourceMappingURL=SectionGraphicsProvider.js.map

package/lib/esm/SectionMarkerHandler.d.ts

@@ -1,53 +1,53 @@
-/** @packageDocumentation
- * @module HyperModeling
- */
-import type { AbstractToolbarProps } from "@itwin/appui-abstract";
-import { SectionMarker } from "./SectionMarkers";
-import { SectionMarkerConfig } from "./HyperModelingConfig";
-import { HyperModelingDecorator } from "./HyperModelingDecorator";
-/** Supplies interactions with [[SectionMarker]]s, including a mini-toolbar displayed when the mouse hovers over a marker and what action occurs when the user clicks a marker.
- * The base implementation supplies the following interactions:
- *  * Click: Toggle display of the section graphics and clip volume; apply the section's spatial view if toggling on.
- *  * Toolbar:
- *    * Apply Section: Applies the section location's spatial view to the viewport and displays the 2d section graphics.
- *    * Open Drawing: Navigates to the section drawing view. By default, this applies the section drawing view to the viewport.
- *    * Open Sheet: Navigates to the [ViewAttachment]($backend) of the section drawing on a [Sheet]($backend). Disabled if no such attachment exists.
- * @see [[HyperModelingConfig]] to override the default handler by supplying a subclass of `SectionMarkerHandler`.
- * @see [[HyperModelingDecorator]] for various methods that might be usefully wired up to marker click or toolbar actions.
- * @public
- */
-export declare class SectionMarkerHandler {
-    /** Respond to activation of the specified marker. Return true if the marker should become the active marker - i.e., if the marker was successfully activated.
-     * @see [[SectionMarkerHandler.deactivateMarker]].
-     */
-    activateMarker(marker: SectionMarker, decorator: HyperModelingDecorator): Promise<boolean>;
-    /** Respond to deactivation of the specified marker. Invoked when the user clicks on the marker while it is the active marker.
-     * This should perform the inverse of [[SectionMarkerHandler.activateMarker]]. The marker becomes inactive as a result.
-     */
-    deactivateMarker(marker: SectionMarker, decorator: HyperModelingDecorator): Promise<void>;
-    /** Return toolbar items for the specified marker. If the array of toolbar items is empty, no toolbar will be displayed.
-     * @see [[executeCommand]] to implement each toolbar command.
-     */
-    getToolbarProps(marker: SectionMarker, _decorator: HyperModelingDecorator): AbstractToolbarProps;
-    /** Execute the command associated with the specified tool bar item.
-     * @see [[getToolbarProps]] to define the set of commands.
-     */
-    executeCommand(commandId: string, marker: SectionMarker, decorator: HyperModelingDecorator): Promise<void>;
-    /** Customize which markers are visible. [[HyperModelingDecorator]] determines marker visibility as follows:
-     *  - If a marker is currently active (selected), only that marker is visible.
-     *  - Otherwise, the marker is visible if this method returns `true`.
-     * The default implementation of this method determines visibility based on the [[SectionMarkerConfig]] as follows.
-     *  - If the marker is of a type included in the config's `hiddenSectionTypes`, it is invisible.
-     *  - If the marker belongs to a model not currently displayed in the viewport and the config's `ignoreModelSelector` is false, it is invisible.
-     *  - If the marker belongs to a category not currently displayed in the viewport and the config's `ignoreCategorySelector` is false, it is invisible,
-     *  - Otherwise, the marker is visible, unless this method returns `false`.
-     * The default implementation of this method always returns `true`
-     * @param marker The marker whose visibility is to be determined.
-     * @param decorator The hypermodeling decorator to which the marker belongs.
-     * @param config The configuration controlling marker visibility based on [SectionType]($common), [ModelSelectorState]($frontend), and [CategorySelectorState]($frontend).
-     * @returns true if the marker should be displayed; false to make it invisible.
-     * @see [[HyperModelingDecorator.requestSync]] to force the decorator to reevaluate marker visibility when the criterion used by your implementation of this method changes.
-     */
-    isMarkerVisible(marker: SectionMarker, decorator: HyperModelingDecorator, config: SectionMarkerConfig): boolean;
-}
+/** @packageDocumentation
+ * @module HyperModeling
+ */
+import type { AbstractToolbarProps } from "@itwin/appui-abstract";
+import { SectionMarker } from "./SectionMarkers";
+import { SectionMarkerConfig } from "./HyperModelingConfig";
+import { HyperModelingDecorator } from "./HyperModelingDecorator";
+/** Supplies interactions with [[SectionMarker]]s, including a mini-toolbar displayed when the mouse hovers over a marker and what action occurs when the user clicks a marker.
+ * The base implementation supplies the following interactions:
+ *  * Click: Toggle display of the section graphics and clip volume; apply the section's spatial view if toggling on.
+ *  * Toolbar:
+ *    * Apply Section: Applies the section location's spatial view to the viewport and displays the 2d section graphics.
+ *    * Open Drawing: Navigates to the section drawing view. By default, this applies the section drawing view to the viewport.
+ *    * Open Sheet: Navigates to the [ViewAttachment]($backend) of the section drawing on a [Sheet]($backend). Disabled if no such attachment exists.
+ * @see [[HyperModelingConfig]] to override the default handler by supplying a subclass of `SectionMarkerHandler`.
+ * @see [[HyperModelingDecorator]] for various methods that might be usefully wired up to marker click or toolbar actions.
+ * @public
+ */
+export declare class SectionMarkerHandler {
+    /** Respond to activation of the specified marker. Return true if the marker should become the active marker - i.e., if the marker was successfully activated.
+     * @see [[SectionMarkerHandler.deactivateMarker]].
+     */
+    activateMarker(marker: SectionMarker, decorator: HyperModelingDecorator): Promise<boolean>;
+    /** Respond to deactivation of the specified marker. Invoked when the user clicks on the marker while it is the active marker.
+     * This should perform the inverse of [[SectionMarkerHandler.activateMarker]]. The marker becomes inactive as a result.
+     */
+    deactivateMarker(marker: SectionMarker, decorator: HyperModelingDecorator): Promise<void>;
+    /** Return toolbar items for the specified marker. If the array of toolbar items is empty, no toolbar will be displayed.
+     * @see [[executeCommand]] to implement each toolbar command.
+     */
+    getToolbarProps(marker: SectionMarker, _decorator: HyperModelingDecorator): AbstractToolbarProps;
+    /** Execute the command associated with the specified tool bar item.
+     * @see [[getToolbarProps]] to define the set of commands.
+     */
+    executeCommand(commandId: string, marker: SectionMarker, decorator: HyperModelingDecorator): Promise<void>;
+    /** Customize which markers are visible. [[HyperModelingDecorator]] determines marker visibility as follows:
+     *  - If a marker is currently active (selected), only that marker is visible.
+     *  - Otherwise, the marker is visible if this method returns `true`.
+     * The default implementation of this method determines visibility based on the [[SectionMarkerConfig]] as follows.
+     *  - If the marker is of a type included in the config's `hiddenSectionTypes`, it is invisible.
+     *  - If the marker belongs to a model not currently displayed in the viewport and the config's `ignoreModelSelector` is false, it is invisible.
+     *  - If the marker belongs to a category not currently displayed in the viewport and the config's `ignoreCategorySelector` is false, it is invisible,
+     *  - Otherwise, the marker is visible, unless this method returns `false`.
+     * The default implementation of this method always returns `true`
+     * @param marker The marker whose visibility is to be determined.
+     * @param decorator The hypermodeling decorator to which the marker belongs.
+     * @param config The configuration controlling marker visibility based on [SectionType]($common), [ModelSelectorState]($frontend), and [CategorySelectorState]($frontend).
+     * @returns true if the marker should be displayed; false to make it invisible.
+     * @see [[HyperModelingDecorator.requestSync]] to force the decorator to reevaluate marker visibility when the criterion used by your implementation of this method changes.
+     */
+    isMarkerVisible(marker: SectionMarker, decorator: HyperModelingDecorator, config: SectionMarkerConfig): boolean;
+}
 //# sourceMappingURL=SectionMarkerHandler.d.ts.map