@itwin/core-backend 3.0.0-dev.100

package/lib/cjs/ViewDefinition.js

@@ -0,0 +1,623 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module ViewDefinitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightLocation = exports.ViewAttachment = exports.AuxCoordSystemSpatial = exports.AuxCoordSystem3d = exports.AuxCoordSystem2d = exports.AuxCoordSystem = exports.TemplateViewDefinition3d = exports.TemplateViewDefinition2d = exports.SheetViewDefinition = exports.DrawingViewDefinition = exports.ViewDefinition2d = exports.OrthographicViewDefinition = exports.SpatialViewDefinition = exports.ViewDefinition3d = exports.ViewDefinition = exports.CategorySelector = exports.ModelSelector = void 0;
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_geometry_1 = require("@itwin/core-geometry");
+const core_common_1 = require("@itwin/core-common");
+const Element_1 = require("./Element");
+/** Holds the list of Ids of GeometricModels displayed by a [[SpatialViewDefinition]]. Multiple SpatialViewDefinitions may point to the same ModelSelector.
+ * @see [ModelSelectorState]($frontend)
+ * See [how to create a ModelSelector]$(docs/learning/backend/CreateElements.md#ModelSelector).
+ * @public
+ */
+class ModelSelector extends Element_1.DefinitionElement {
+    /** @internal */
+    constructor(props, iModel) { super(props, iModel); this.models = props.models; }
+    /** @internal */
+    static get className() { return "ModelSelector"; }
+    /** @internal */
+    toJSON() {
+        const val = super.toJSON();
+        val.models = this.models;
+        return val;
+    }
+    /** @internal */
+    collectPredecessorIds(predecessorIds) {
+        super.collectPredecessorIds(predecessorIds);
+        this.models.forEach((modelId) => predecessorIds.add(modelId));
+    }
+    /** Create a Code for a ModelSelector given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param scopeModelId The Id of the DefinitionModel that contains the ModelSelector and provides the scope for its name.
+     * @param codeValue The ModelSelector name
+     */
+    static createCode(iModel, scopeModelId, codeValue) {
+        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.modelSelector);
+        return new core_common_1.Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+    /**
+     * Create a ModelSelector to select which Models are displayed by a ViewDefinition.
+     * @param iModelDb The iModel
+     * @param definitionModelId The [[DefinitionModel]]
+     * @param name The name/CodeValue of the ModelSelector
+     * @param models Array of models to select for display
+     * @returns The newly constructed ModelSelector element.
+     * @throws [[IModelError]] if unable to create the element.
+     */
+    static create(iModelDb, definitionModelId, name, models) {
+        const modelSelectorProps = {
+            classFullName: this.classFullName,
+            code: this.createCode(iModelDb, definitionModelId, name),
+            model: definitionModelId,
+            models,
+            isPrivate: false,
+        };
+        return new ModelSelector(modelSelectorProps, iModelDb);
+    }
+    /**
+     * Insert a ModelSelector to select which Models are displayed by a ViewDefinition.
+     * @param iModelDb Insert into this iModel
+     * @param definitionModelId Insert the new ModelSelector into this DefinitionModel
+     * @param name The name/CodeValue of the ModelSelector
+     * @param models Array of models to select for display
+     * @returns The Id of the newly inserted ModelSelector element.
+     * @throws [[IModelError]] if unable to insert the element.
+     */
+    static insert(iModelDb, definitionModelId, name, models) {
+        const modelSelector = this.create(iModelDb, definitionModelId, name, models);
+        return iModelDb.elements.insertElement(modelSelector);
+    }
+}
+exports.ModelSelector = ModelSelector;
+/** Holds a list of Ids of Categories to be displayed in a view.
+ * @see [CategorySelectorState]($frontend)
+ * See [how to create a CategorySelector]$(docs/learning/backend/CreateElements.md#CategorySelector).
+ * @public
+ */
+class CategorySelector extends Element_1.DefinitionElement {
+    /** @internal */
+    constructor(props, iModel) { super(props, iModel); this.categories = props.categories; }
+    /** @internal */
+    static get className() { return "CategorySelector"; }
+    /** @internal */
+    toJSON() {
+        const val = super.toJSON();
+        val.categories = this.categories;
+        return val;
+    }
+    /** @internal */
+    collectPredecessorIds(predecessorIds) {
+        super.collectPredecessorIds(predecessorIds);
+        this.categories.forEach((categoryId) => predecessorIds.add(categoryId));
+    }
+    /** Create a Code for a CategorySelector given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param scopeModelId The Id of the DefinitionModel that contains the CategorySelector and provides the scope for its name.
+     * @param codeValue The CategorySelector name
+     */
+    static createCode(iModel, scopeModelId, codeValue) {
+        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.categorySelector);
+        return new core_common_1.Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+    /**
+     * Create a CategorySelector to select which categories are displayed by a ViewDefinition.
+     * @param iModelDb The iModel
+     * @param definitionModelId The [[DefinitionModel]]
+     * @param name The name of the CategorySelector
+     * @param categories Array of categories to select for display
+     * @returns The newly constructed CategorySelector element.
+     * @throws [[IModelError]] if unable to create the element.
+     */
+    static create(iModelDb, definitionModelId, name, categories) {
+        const categorySelectorProps = {
+            classFullName: this.classFullName,
+            code: this.createCode(iModelDb, definitionModelId, name),
+            model: definitionModelId,
+            categories,
+            isPrivate: false,
+        };
+        return new CategorySelector(categorySelectorProps, iModelDb);
+    }
+    /**
+     * Insert a CategorySelector to select which categories are displayed by a ViewDefinition.
+     * @param iModelDb Insert into this iModel
+     * @param definitionModelId Insert the new CategorySelector into this DefinitionModel
+     * @param name The name of the CategorySelector
+     * @param categories Array of categories to select for display
+     * @returns The Id of the newly inserted CategorySelector element.
+     * @throws [[IModelError]] if unable to insert the element.
+     */
+    static insert(iModelDb, definitionModelId, name, categories) {
+        const categorySelector = this.create(iModelDb, definitionModelId, name, categories);
+        return iModelDb.elements.insertElement(categorySelector);
+    }
+}
+exports.CategorySelector = CategorySelector;
+/**
+ * The definition element for a view. ViewDefinitions specify the area/volume that is viewed, the Ids of a DisplayStyle and a CategorySelector,
+ * plus additional view-specific parameters in their [[Element.jsonProperties]].
+ *
+ * Subclasses of ViewDefinition determine which model(s) are viewed.
+ *
+ * **Example: Obtaining the background color for a view**
+ * ``` ts
+ * [[include:ViewDefinition.getBackgroundColor]]
+ * ```
+ *
+ * @note ViewDefinition is only available in the backend. See [ViewState]($frontend) for usage in the frontend.
+ * @public
+ */
+class ViewDefinition extends Element_1.DefinitionElement {
+    /** @internal */
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.categorySelectorId = core_bentley_1.Id64.fromJSON(props.categorySelectorId);
+        if (!core_bentley_1.Id64.isValid(this.categorySelectorId))
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadArg, `categorySelectorId is invalid`);
+        this.displayStyleId = core_bentley_1.Id64.fromJSON(props.displayStyleId);
+        if (!core_bentley_1.Id64.isValid(this.displayStyleId))
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadArg, `displayStyleId is invalid`);
+    }
+    /** @internal */
+    static get className() { return "ViewDefinition"; }
+    /** @internal */
+    toJSON() {
+        const json = super.toJSON();
+        json.categorySelectorId = this.categorySelectorId;
+        json.displayStyleId = this.displayStyleId;
+        return json;
+    }
+    /** @internal */
+    collectPredecessorIds(predecessorIds) {
+        super.collectPredecessorIds(predecessorIds);
+        predecessorIds.add(this.categorySelectorId);
+        predecessorIds.add(this.displayStyleId);
+        const acsId = this.getAuxiliaryCoordinateSystemId();
+        if (core_bentley_1.Id64.isValidId64(acsId)) {
+            predecessorIds.add(acsId);
+        }
+    }
+    /** @internal */
+    static onCloned(context, sourceElementProps, targetElementProps) {
+        super.onCloned(context, sourceElementProps, targetElementProps);
+        if (context.isBetweenIModels && targetElementProps.jsonProperties && targetElementProps.jsonProperties.viewDetails) {
+            const acsId = core_bentley_1.Id64.fromJSON(targetElementProps.jsonProperties.viewDetails.acs);
+            if (core_bentley_1.Id64.isValidId64(acsId)) {
+                targetElementProps.jsonProperties.viewDetails.acs = context.findTargetElementId(acsId);
+            }
+        }
+    }
+    /** Type guard for `instanceof ViewDefinition3d`  */
+    isView3d() { return this instanceof ViewDefinition3d; }
+    /** Type guard for 'instanceof ViewDefinition2d` */
+    isView2d() { return this instanceof ViewDefinition2d; }
+    /** Type guard for `instanceof SpatialViewDefinition` */
+    isSpatialView() { return this instanceof SpatialViewDefinition; }
+    /** Type guard for 'instanceof DrawingViewDefinition' */
+    isDrawingView() { return this instanceof DrawingViewDefinition; }
+    /** Load this view's DisplayStyle from the IModelDb. */
+    loadDisplayStyle() { return this.iModel.elements.getElement(this.displayStyleId); }
+    /** Load this view's CategorySelector from the IModelDb. */
+    loadCategorySelector() { return this.iModel.elements.getElement(this.categorySelectorId); }
+    /** The Id of the AuxiliaryCoordinateSystem for this ViewDefinition, or an invalid Id if no ACS is defined. */
+    getAuxiliaryCoordinateSystemId() {
+        return this.details.auxiliaryCoordinateSystemId;
+    }
+    /** Set or clear the AuxiliaryCoordinateSystem for this ViewDefinition.
+     * @param acsId The Id of the new AuxiliaryCoordinateSystem. If `Id64.invalid` is passed, then no AuxiliaryCoordinateSystem will be used.
+     */
+    setAuxiliaryCoordinateSystemId(acsId) {
+        this.details.auxiliaryCoordinateSystemId = acsId;
+    }
+    /** Create a Code for a ViewDefinition given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param scopeModelId The Id of the DefinitionModel to contain the ViewDefinition and provides the scope for its name.
+     * @param codeValue The ViewDefinition name
+     */
+    static createCode(iModel, scopeModelId, codeValue) {
+        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.viewDefinition);
+        return new core_common_1.Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+}
+exports.ViewDefinition = ViewDefinition;
+/** Defines a view of one or more 3d models.
+ * @public
+ */
+class ViewDefinition3d extends ViewDefinition {
+    /** @internal */
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.cameraOn = core_bentley_1.JsonUtils.asBool(props.cameraOn);
+        this.origin = core_geometry_1.Point3d.fromJSON(props.origin);
+        this.extents = core_geometry_1.Vector3d.fromJSON(props.extents);
+        this.angles = core_geometry_1.YawPitchRollAngles.fromJSON(props.angles);
+        this.camera = new core_common_1.Camera(props.camera);
+        this._details = new core_common_1.ViewDetails3d(this.jsonProperties);
+    }
+    /** @internal */
+    static get className() { return "ViewDefinition3d"; }
+    /** @internal */
+    toJSON() {
+        const val = super.toJSON();
+        val.cameraOn = this.cameraOn;
+        val.origin = this.origin;
+        val.extents = this.extents;
+        val.angles = this.angles;
+        val.camera = this.camera;
+        return val;
+    }
+    /** Provides access to optional detail settings for this view. */
+    get details() { return this._details; }
+    /** Load this view's DisplayStyle3d from the IModelDb. */
+    loadDisplayStyle3d() { return this.iModel.elements.getElement(this.displayStyleId); }
+}
+exports.ViewDefinition3d = ViewDefinition3d;
+/** Defines a view of one or more SpatialModels.
+ * The list of viewed models is stored by the ModelSelector.
+ *
+ * This is how a SpatialViewDefinition selects the elements to display:
+ *
+ *  SpatialViewDefinition
+ *    * ModelSelector
+ *        * ModelIds  -------> SpatialModels    <----------GeometricElement3d.Model
+ *    * CategorySelector
+ *        * CategoryIds -----> SpatialCategories <----------GeometricElement3d.Category
+ * @public
+ */
+class SpatialViewDefinition extends ViewDefinition3d {
+    /** @internal */
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.modelSelectorId = core_bentley_1.Id64.fromJSON(props.modelSelectorId);
+        if (!core_bentley_1.Id64.isValid(this.modelSelectorId))
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadArg, `modelSelectorId is invalid`);
+    }
+    /** @internal */
+    static get className() { return "SpatialViewDefinition"; }
+    /** @internal */
+    toJSON() {
+        const json = super.toJSON();
+        json.modelSelectorId = this.modelSelectorId;
+        return json;
+    }
+    /** @internal */
+    collectPredecessorIds(predecessorIds) {
+        super.collectPredecessorIds(predecessorIds);
+        predecessorIds.add(this.modelSelectorId);
+    }
+    /** Load this view's ModelSelector from the IModelDb. */
+    loadModelSelector() { return this.iModel.elements.getElement(this.modelSelectorId); }
+    /**
+     * Create an SpatialViewDefinition with camera.
+     * @param iModelDb The iModel
+     * @param definitionModelId The [[DefinitionModel]]
+     * @param name The name/CodeValue of the view
+     * @param modelSelectorId The [[ModelSelector]] that this view should use
+     * @param categorySelectorId The [[CategorySelector]] that this view should use
+     * @param displayStyleId The [[DisplayStyle3d]] that this view should use
+     * @param range Defines the view origin and extents
+     * @param standardView Optionally defines the view's rotation
+     * @param cameraAngle Camera angle in radians.
+     * @returns The newly constructed OrthographicViewDefinition element
+     * @throws [[IModelError]] if there is a problem creating the view
+     */
+    static createWithCamera(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView = core_geometry_1.StandardViewIndex.Iso, cameraAngle = core_geometry_1.Angle.piOver2Radians) {
+        const rotation = core_geometry_1.Matrix3d.createStandardWorldToView(standardView);
+        const angles = core_geometry_1.YawPitchRollAngles.createFromMatrix3d(rotation);
+        const rotationTransform = core_geometry_1.Transform.createOriginAndMatrix(undefined, rotation);
+        const rotatedRange = rotationTransform.multiplyRange(range);
+        const cameraDistance = 2 * (rotatedRange.diagonal().magnitudeXY() / 2.0) / Math.tan(cameraAngle / 2.0);
+        const cameraLocation = rotatedRange.diagonalFractionToPoint(.5); // Start at center.
+        cameraLocation.z += cameraDistance; // Back up by camera distance.
+        rotation.multiplyTransposeVectorInPlace(cameraLocation);
+        const viewDefinitionProps = {
+            classFullName: this.classFullName,
+            model: definitionModelId,
+            code: this.createCode(iModelDb, definitionModelId, name),
+            modelSelectorId,
+            categorySelectorId,
+            displayStyleId,
+            origin: rotation.multiplyTransposeXYZ(rotatedRange.low.x, rotatedRange.low.y, rotatedRange.low.z),
+            extents: rotatedRange.diagonal(),
+            angles,
+            cameraOn: true,
+            camera: { lens: { radians: cameraAngle }, focusDist: cameraDistance, eye: cameraLocation },
+        };
+        return new SpatialViewDefinition(viewDefinitionProps, iModelDb);
+    }
+    /**
+     * Insert an SpatialViewDefinition with camera On
+     * @param iModelDb Insert into this iModel
+     * @param definitionModelId Insert the new OrthographicViewDefinition into this DefinitionModel
+     * @param name The name/CodeValue of the view
+     * @param modelSelectorId The [[ModelSelector]] that this view should use
+     * @param categorySelectorId The [[CategorySelector]] that this view should use
+     * @param displayStyleId The [[DisplayStyle3d]] that this view should use
+     * @param range Defines the view origin and extents
+     * @param standardView Optionally defines the view's rotation
+     * @param cameraAngle Camera angle in radians.
+     * @returns The Id of the newly inserted OrthographicViewDefinition element
+     * @throws [[IModelError]] if there is an insert problem.
+     */
+    static insertWithCamera(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView = core_geometry_1.StandardViewIndex.Iso, cameraAngle = core_geometry_1.Angle.piOver2Radians) {
+        const viewDefinition = this.createWithCamera(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView, cameraAngle);
+        return iModelDb.elements.insertElement(viewDefinition);
+    }
+}
+exports.SpatialViewDefinition = SpatialViewDefinition;
+/** Defines a spatial view that displays geometry on the image plane using a parallel orthographic projection.
+ * See [how to create a OrthographicViewDefinition]$(docs/learning/backend/CreateElements.md#OrthographicViewDefinition).
+ * @public
+ */
+class OrthographicViewDefinition extends SpatialViewDefinition {
+    /** @internal */
+    static get className() { return "OrthographicViewDefinition"; }
+    constructor(props, iModel) { super(props, iModel); }
+    /**
+     * Create an OrthographicViewDefinition
+     * @param iModelDb The iModel
+     * @param definitionModelId The [[DefinitionModel]]
+     * @param name The name/CodeValue of the view
+     * @param modelSelectorId The [[ModelSelector]] that this view should use
+     * @param categorySelectorId The [[CategorySelector]] that this view should use
+     * @param displayStyleId The [[DisplayStyle3d]] that this view should use
+     * @param range Defines the view origin and extents
+     * @param standardView Optionally defines the view's rotation
+     * @returns The newly constructed OrthographicViewDefinition element
+     * @throws [[IModelError]] if there is a problem creating the view
+     */
+    static create(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView = core_geometry_1.StandardViewIndex.Iso) {
+        const rotation = core_geometry_1.Matrix3d.createStandardWorldToView(standardView);
+        const angles = core_geometry_1.YawPitchRollAngles.createFromMatrix3d(rotation);
+        const rotationTransform = core_geometry_1.Transform.createOriginAndMatrix(undefined, rotation);
+        const rotatedRange = rotationTransform.multiplyRange(range);
+        const viewDefinitionProps = {
+            classFullName: this.classFullName,
+            model: definitionModelId,
+            code: this.createCode(iModelDb, definitionModelId, name),
+            modelSelectorId,
+            categorySelectorId,
+            displayStyleId,
+            origin: rotation.multiplyTransposeXYZ(rotatedRange.low.x, rotatedRange.low.y, rotatedRange.low.z),
+            extents: rotatedRange.diagonal(),
+            angles,
+            cameraOn: false,
+            camera: new core_common_1.Camera(), // not used when cameraOn === false
+        };
+        return new OrthographicViewDefinition(viewDefinitionProps, iModelDb);
+    }
+    /**
+     * Insert an OrthographicViewDefinition
+     * @param iModelDb Insert into this iModel
+     * @param definitionModelId Insert the new OrthographicViewDefinition into this DefinitionModel
+     * @param name The name/CodeValue of the view
+     * @param modelSelectorId The [[ModelSelector]] that this view should use
+     * @param categorySelectorId The [[CategorySelector]] that this view should use
+     * @param displayStyleId The [[DisplayStyle3d]] that this view should use
+     * @param range Defines the view origin and extents
+     * @param standardView Optionally defines the view's rotation
+     * @returns The Id of the newly inserted OrthographicViewDefinition element
+     * @throws [[IModelError]] if there is an insert problem.
+     */
+    static insert(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView = core_geometry_1.StandardViewIndex.Iso) {
+        const viewDefinition = this.create(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView);
+        return iModelDb.elements.insertElement(viewDefinition);
+    }
+    /** Set a new viewed range without changing the rotation or any other properties. */
+    setRange(range) {
+        const rotation = this.angles.toMatrix3d();
+        const rotationTransform = core_geometry_1.Transform.createOriginAndMatrix(undefined, rotation);
+        const rotatedRange = rotationTransform.multiplyRange(range);
+        this.origin = core_geometry_1.Point3d.createFrom(rotation.multiplyTransposeXYZ(rotatedRange.low.x, rotatedRange.low.y, rotatedRange.low.z));
+        this.extents = rotatedRange.diagonal();
+    }
+}
+exports.OrthographicViewDefinition = OrthographicViewDefinition;
+/** Defines a view of a single 2d model. Each 2d model has its own coordinate system, so only one may appear per view.
+ * @public
+ */
+class ViewDefinition2d extends ViewDefinition {
+    /** @internal */
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.baseModelId = core_bentley_1.Id64.fromJSON(props.baseModelId);
+        this.origin = core_geometry_1.Point2d.fromJSON(props.origin);
+        this.delta = core_geometry_1.Point2d.fromJSON(props.delta);
+        this.angle = core_geometry_1.Angle.fromJSON(props.angle);
+        this._details = new core_common_1.ViewDetails(this.jsonProperties);
+    }
+    /** @internal */
+    static get className() { return "ViewDefinition2d"; }
+    /** @internal */
+    toJSON() {
+        const val = super.toJSON();
+        val.baseModelId = this.baseModelId;
+        val.origin = this.origin;
+        val.delta = this.delta;
+        val.angle = this.angle;
+        return val;
+    }
+    /** @internal */
+    collectPredecessorIds(predecessorIds) {
+        super.collectPredecessorIds(predecessorIds);
+        predecessorIds.add(this.baseModelId);
+    }
+    /** Provides access to optional detail settings for this view. */
+    get details() { return this._details; }
+    /** Load this view's DisplayStyle2d from the IModelDb. */
+    loadDisplayStyle2d() { return this.iModel.elements.getElement(this.displayStyleId); }
+}
+exports.ViewDefinition2d = ViewDefinition2d;
+/** Defines a view of a [[DrawingModel]].
+ * @public
+ */
+class DrawingViewDefinition extends ViewDefinition2d {
+    /** @internal */
+    static get className() { return "DrawingViewDefinition"; }
+    /** @internal */
+    constructor(props, iModel) {
+        super(props, iModel);
+    }
+    /** Create a DrawingViewDefinition
+     * @param iModelDb The iModel
+     * @param definitionModelId The [[DefinitionModel]]
+     * @param name The name/CodeValue of the view
+     * @param baseModelId The base [[DrawingModel]]
+     * @param categorySelectorId The [[CategorySelector]] that this view should use
+     * @param displayStyleId The [[DisplayStyle2d]] that this view should use
+     * @param range Defines the view origin and extents
+     * @throws [[IModelError]] if there is a problem creating the element.
+     */
+    static create(iModelDb, definitionModelId, name, baseModelId, categorySelectorId, displayStyleId, range) {
+        const viewDefinitionProps = {
+            classFullName: this.classFullName,
+            model: definitionModelId,
+            code: this.createCode(iModelDb, definitionModelId, name),
+            baseModelId,
+            categorySelectorId,
+            displayStyleId,
+            origin: { x: range.low.x, y: range.low.y },
+            delta: range.diagonal(),
+            angle: 0,
+        };
+        return new DrawingViewDefinition(viewDefinitionProps, iModelDb);
+    }
+    /** Insert a DrawingViewDefinition
+     * @param iModelDb Insert into this iModel
+     * @param definitionModelId Insert the new DrawingViewDefinition into this [[DefinitionModel]]
+     * @param name The name/CodeValue of the view
+     * @param baseModelId The base [[DrawingModel]]
+     * @param categorySelectorId The [[CategorySelector]] that this view should use
+     * @param displayStyleId The [[DisplayStyle2d]] that this view should use
+     * @param range Defines the view origin and extents
+     * @throws [[IModelError]] if there is an insert problem.
+     */
+    static insert(iModelDb, definitionModelId, name, baseModelId, categorySelectorId, displayStyleId, range) {
+        const viewDefinition = this.create(iModelDb, definitionModelId, name, baseModelId, categorySelectorId, displayStyleId, range);
+        return iModelDb.elements.insertElement(viewDefinition);
+    }
+}
+exports.DrawingViewDefinition = DrawingViewDefinition;
+/** Defines a view of a [[SheetModel]].
+ * @public
+ */
+class SheetViewDefinition extends ViewDefinition2d {
+    /** @internal */
+    static get className() { return "SheetViewDefinition"; }
+}
+exports.SheetViewDefinition = SheetViewDefinition;
+/** A ViewDefinition used to display a 2d template model.
+ * @internal
+ */
+class TemplateViewDefinition2d extends ViewDefinition2d {
+    /** @internal */
+    static get className() { return "TemplateViewDefinition2d"; }
+}
+exports.TemplateViewDefinition2d = TemplateViewDefinition2d;
+/** A ViewDefinition used to display a 3d template model.
+ * @internal
+ */
+class TemplateViewDefinition3d extends ViewDefinition3d {
+    /** @internal */
+    static get className() { return "TemplateViewDefinition3d"; }
+}
+exports.TemplateViewDefinition3d = TemplateViewDefinition3d;
+/** An auxiliary coordinate system element. Auxiliary coordinate systems can be used by views to show
+ * coordinate information in different units and/or orientations.
+ * @public
+ */
+class AuxCoordSystem extends Element_1.DefinitionElement {
+    constructor(props, iModel) { super(props, iModel); }
+    /** @internal */
+    static get className() { return "AuxCoordSystem"; }
+}
+exports.AuxCoordSystem = AuxCoordSystem;
+/** A 2d auxiliary coordinate system.
+ * @public
+ */
+class AuxCoordSystem2d extends AuxCoordSystem {
+    constructor(props, iModel) { super(props, iModel); }
+    /** @internal */
+    static get className() { return "AuxCoordSystem2d"; }
+    /** Create a Code for a AuxCoordSystem2d element given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param scopeModelId The Id of the DefinitionModel that contains the AuxCoordSystem2d element and provides the scope for its name.
+     * @param codeValue The AuxCoordSystem2d name
+     */
+    static createCode(iModel, scopeModelId, codeValue) {
+        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.auxCoordSystem2d);
+        return new core_common_1.Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+}
+exports.AuxCoordSystem2d = AuxCoordSystem2d;
+/** A 3d auxiliary coordinate system.
+ * @public
+ */
+class AuxCoordSystem3d extends AuxCoordSystem {
+    constructor(props, iModel) { super(props, iModel); }
+    /** @internal */
+    static get className() { return "AuxCoordSystem3d"; }
+    /** Create a Code for a AuxCoordSystem3d element given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param scopeModelId The Id of the DefinitionModel that contains the AuxCoordSystem3d element and provides the scope for its name.
+     * @param codeValue The AuxCoordSystem3d name
+     */
+    static createCode(iModel, scopeModelId, codeValue) {
+        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.auxCoordSystem3d);
+        return new core_common_1.Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+}
+exports.AuxCoordSystem3d = AuxCoordSystem3d;
+/** A spatial auxiliary coordinate system.
+ * @public
+ */
+class AuxCoordSystemSpatial extends AuxCoordSystem3d {
+    /** @internal */
+    static get className() { return "AuxCoordSystemSpatial"; }
+    /** Create a Code for a AuxCoordSystemSpatial element given a name that is meant to be unique within the scope of the specified DefinitionModel.
+     * @param iModel  The IModelDb
+     * @param scopeModelId The Id of the DefinitionModel that contains the AuxCoordSystemSpatial element and provides the scope for its name.
+     * @param codeValue The AuxCoordSystemSpatial name
+     */
+    static createCode(iModel, scopeModelId, codeValue) {
+        const codeSpec = iModel.codeSpecs.getByName(core_common_1.BisCodeSpec.auxCoordSystemSpatial);
+        return new core_common_1.Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+}
+exports.AuxCoordSystemSpatial = AuxCoordSystemSpatial;
+/** Represents an *attachment* of a [[ViewDefinition]] to a [[Sheet]].
+ * @public
+ */
+class ViewAttachment extends Element_1.GraphicalElement2d {
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.view = new core_common_1.RelatedElement(props.view);
+        // ###NOTE: scale, displayPriority, and clipping vectors are stored in ViewAttachmentProps.jsonProperties.
+    }
+    /** @internal */
+    static get className() { return "ViewAttachment"; }
+    /** @internal */
+    collectPredecessorIds(predecessorIds) {
+        super.collectPredecessorIds(predecessorIds);
+        predecessorIds.add(this.view.id);
+    }
+}
+exports.ViewAttachment = ViewAttachment;
+/** The position in space of a Light.
+ * @internal
+ */
+class LightLocation extends Element_1.SpatialLocationElement {
+    /** @internal */
+    constructor(props, iModel) { super(props, iModel); }
+    /** @internal */
+    static get className() { return "LightLocation"; }
+}
+exports.LightLocation = LightLocation;
+//# sourceMappingURL=ViewDefinition.js.map