@itwin/core-backend 5.0.0-dev.90 → 5.0.0-dev.93

package/lib/esm/ViewDefinition.js

@@ -0,0 +1,638 @@
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+import { Id64, IModelStatus, JsonUtils } from "@itwin/core-bentley";
+import { Angle, Matrix3d, Point2d, Point3d, StandardViewIndex, Transform, Vector3d, YawPitchRollAngles, } from "@itwin/core-geometry";
+import { BisCodeSpec, Camera, Code, ConcreteEntityTypes, IModelError, RelatedElement, ViewDetails, ViewDetails3d, } from "@itwin/core-common";
+import { DefinitionElement, GraphicalElement2d, SpatialLocationElement } from "./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
+ */
+export class ModelSelector extends DefinitionElement {
+    static get className() { return "ModelSelector"; }
+    /** The array of modelIds of the GeometricModels displayed by this ModelSelector */
+    models;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.models = props.models;
+    }
+    toJSON() {
+        const val = super.toJSON();
+        val.models = this.models;
+        return val;
+    }
+    collectReferenceIds(referenceIds) {
+        super.collectReferenceIds(referenceIds);
+        this.models.forEach((modelId) => referenceIds.addModel(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(BisCodeSpec.modelSelector);
+        return new 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.toJSON());
+    }
+}
+/** 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
+ */
+export class CategorySelector extends DefinitionElement {
+    static get className() { return "CategorySelector"; }
+    /** The array of element Ids of the Categories selected by this CategorySelector */
+    categories;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.categories = props.categories;
+    }
+    toJSON() {
+        const val = super.toJSON();
+        val.categories = this.categories;
+        return val;
+    }
+    collectReferenceIds(referenceIds) {
+        super.collectReferenceIds(referenceIds);
+        this.categories.forEach((categoryId) => referenceIds.addElement(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(BisCodeSpec.categorySelector);
+        return new 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.toJSON());
+    }
+}
+/**
+ * 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.
+ * @note ViewDefinition is only available in the backend. See [ViewState]($frontend) for usage in the frontend.
+ * @public
+ */
+export class ViewDefinition extends DefinitionElement {
+    static get className() { return "ViewDefinition"; }
+    /** The element Id of the [[CategorySelector]] for this ViewDefinition */
+    categorySelectorId;
+    /** The element Id of the [[DisplayStyle]] for this ViewDefinition */
+    displayStyleId;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.categorySelectorId = Id64.fromJSON(props.categorySelectorId);
+        if (!Id64.isValid(this.categorySelectorId))
+            throw new IModelError(IModelStatus.BadArg, `categorySelectorId is invalid`);
+        this.displayStyleId = Id64.fromJSON(props.displayStyleId);
+        if (!Id64.isValid(this.displayStyleId))
+            throw new IModelError(IModelStatus.BadArg, `displayStyleId is invalid`);
+    }
+    toJSON() {
+        const json = super.toJSON();
+        json.categorySelectorId = this.categorySelectorId;
+        json.displayStyleId = this.displayStyleId;
+        return json;
+    }
+    collectReferenceIds(referenceIds) {
+        super.collectReferenceIds(referenceIds);
+        referenceIds.addElement(this.categorySelectorId);
+        referenceIds.addElement(this.displayStyleId);
+        const acsId = this.getAuxiliaryCoordinateSystemId();
+        if (Id64.isValidId64(acsId)) {
+            referenceIds.addElement(acsId);
+        }
+    }
+    /** @beta */
+    static requiredReferenceKeys = [...super.requiredReferenceKeys, "categorySelectorId", "displayStyleId"];
+    /** @alpha */
+    static requiredReferenceKeyTypeMap = {
+        ...super.requiredReferenceKeyTypeMap,
+        categorySelectorId: ConcreteEntityTypes.Element,
+        displayStyleId: ConcreteEntityTypes.Element,
+    };
+    /** @beta */
+    static onCloned(context, sourceElementProps, targetElementProps) {
+        super.onCloned(context, sourceElementProps, targetElementProps);
+        if (context.isBetweenIModels && targetElementProps.jsonProperties && targetElementProps.jsonProperties.viewDetails) {
+            const acsId = Id64.fromJSON(targetElementProps.jsonProperties.viewDetails.acs);
+            if (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(BisCodeSpec.viewDefinition);
+        return new Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+}
+/** Defines a view of one or more 3d models.
+ * @public
+ */
+export class ViewDefinition3d extends ViewDefinition {
+    _details;
+    static get className() { return "ViewDefinition3d"; }
+    /** If true, camera is used. Otherwise, use an orthographic projection. */
+    cameraOn;
+    /** The lower left back corner of the view frustum. */
+    origin;
+    /** The extent (size) of the view frustum, in meters, along its x,y,z axes. */
+    extents;
+    /** Rotation from world coordinates to view coordinates. */
+    angles;
+    /** The camera used for this view, if `cameraOn` is true. */
+    camera;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.cameraOn = JsonUtils.asBool(props.cameraOn);
+        this.origin = Point3d.fromJSON(props.origin);
+        this.extents = Vector3d.fromJSON(props.extents);
+        this.angles = YawPitchRollAngles.fromJSON(props.angles);
+        this.camera = new Camera(props.camera);
+        this._details = new ViewDetails3d(this.jsonProperties);
+    }
+    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); }
+}
+/** 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
+ */
+export class SpatialViewDefinition extends ViewDefinition3d {
+    static get className() { return "SpatialViewDefinition"; }
+    /** The Id of the [[ModelSelector]] for this SpatialViewDefinition. */
+    modelSelectorId;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.modelSelectorId = Id64.fromJSON(props.modelSelectorId);
+        if (!Id64.isValid(this.modelSelectorId))
+            throw new IModelError(IModelStatus.BadArg, `modelSelectorId is invalid`);
+    }
+    /** Construct a SpatialViewDefinition from its JSON representation. */
+    static fromJSON(props, iModel) {
+        return new SpatialViewDefinition({ ...props, classFullName: this.classFullName }, iModel);
+    }
+    toJSON() {
+        const json = super.toJSON();
+        json.modelSelectorId = this.modelSelectorId;
+        return json;
+    }
+    collectReferenceIds(referenceIds) {
+        super.collectReferenceIds(referenceIds);
+        referenceIds.addElement(this.modelSelectorId);
+    }
+    /** @beta */
+    static requiredReferenceKeys = [...super.requiredReferenceKeys, "modelSelectorId"];
+    /** @alpha */
+    static requiredReferenceKeyTypeMap = {
+        ...super.requiredReferenceKeyTypeMap,
+        modelSelectorId: ConcreteEntityTypes.Element,
+    };
+    /** Load this view's ModelSelector from the IModelDb. */
+    loadModelSelector() { return this.iModel.elements.getElement(this.modelSelectorId); }
+    /**
+     * Create a SpatialViewDefinition with the camera turned on.
+     * @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 SpatialViewDefinition element
+     * @throws [[IModelError]] if there is a problem creating the view
+     */
+    static createWithCamera(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView = StandardViewIndex.Iso, cameraAngle = Angle.piOver2Radians) {
+        const rotation = Matrix3d.createStandardWorldToView(standardView);
+        const angles = YawPitchRollAngles.createFromMatrix3d(rotation);
+        const rotationTransform = 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 the camera turned on.
+     * @see [[createWithCamera]] for details.
+     * @returns The Id of the newly inserted SpatialViewDefinition element
+     * @throws [[IModelError]] if there is an insert problem.
+     */
+    static insertWithCamera(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView = StandardViewIndex.Iso, cameraAngle = Angle.piOver2Radians) {
+        const viewDefinition = this.createWithCamera(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView, cameraAngle);
+        return iModelDb.elements.insertElement(viewDefinition.toJSON());
+    }
+}
+/** 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
+ */
+export class OrthographicViewDefinition extends SpatialViewDefinition {
+    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 = StandardViewIndex.Iso) {
+        const rotation = Matrix3d.createStandardWorldToView(standardView);
+        const angles = YawPitchRollAngles.createFromMatrix3d(rotation);
+        const rotationTransform = 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 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 = StandardViewIndex.Iso) {
+        const viewDefinition = this.create(iModelDb, definitionModelId, name, modelSelectorId, categorySelectorId, displayStyleId, range, standardView);
+        return iModelDb.elements.insertElement(viewDefinition.toJSON());
+    }
+    /** Set a new viewed range without changing the rotation or any other properties. */
+    setRange(range) {
+        const rotation = this.angles.toMatrix3d();
+        const rotationTransform = Transform.createOriginAndMatrix(undefined, rotation);
+        const rotatedRange = rotationTransform.multiplyRange(range);
+        this.origin = Point3d.createFrom(rotation.multiplyTransposeXYZ(rotatedRange.low.x, rotatedRange.low.y, rotatedRange.low.z));
+        this.extents = rotatedRange.diagonal();
+    }
+}
+/** Defines a view of a single 2d model. Each 2d model has its own coordinate system, so only one may appear per view.
+ * @public
+ */
+export class ViewDefinition2d extends ViewDefinition {
+    _details;
+    static get className() { return "ViewDefinition2d"; }
+    /** The Id of the Model displayed by this view. */
+    baseModelId;
+    /** The lower-left corner of this view in Model coordinates. */
+    origin;
+    /** The delta (size) of this view, in meters, aligned with view x,y. */
+    delta;
+    /** The rotation of this view. */
+    angle;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.baseModelId = Id64.fromJSON(props.baseModelId);
+        this.origin = Point2d.fromJSON(props.origin);
+        this.delta = Point2d.fromJSON(props.delta);
+        this.angle = Angle.fromJSON(props.angle);
+        this._details = new ViewDetails(this.jsonProperties);
+    }
+    toJSON() {
+        const val = super.toJSON();
+        val.baseModelId = this.baseModelId;
+        val.origin = this.origin;
+        val.delta = this.delta;
+        val.angle = this.angle;
+        return val;
+    }
+    collectReferenceIds(referenceIds) {
+        super.collectReferenceIds(referenceIds);
+        referenceIds.addElement(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); }
+}
+/** Defines a view of a [[DrawingModel]].
+ * @public
+ */
+export class DrawingViewDefinition extends ViewDefinition2d {
+    static get className() { return "DrawingViewDefinition"; }
+    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);
+    }
+    /** Construct a DrawingViewDefinition from its JSON representation. */
+    static fromJSON(props, iModel) {
+        return new DrawingViewDefinition({ ...props, classFullName: this.classFullName }, iModel);
+    }
+    /** 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.toJSON());
+    }
+}
+/** Defines a view of a [[SheetModel]].
+ * @public
+ */
+export class SheetViewDefinition extends ViewDefinition2d {
+    static get className() { return "SheetViewDefinition"; }
+}
+/** A ViewDefinition used to display a 2d template model.
+ * @internal
+ */
+export class TemplateViewDefinition2d extends ViewDefinition2d {
+    static get className() { return "TemplateViewDefinition2d"; }
+}
+/** A ViewDefinition used to display a 3d template model.
+ * @internal
+ */
+export class TemplateViewDefinition3d extends ViewDefinition3d {
+    static get className() { return "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
+ */
+export class AuxCoordSystem extends DefinitionElement {
+    static get className() { return "AuxCoordSystem"; }
+    type;
+    description;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.type = props.type;
+        this.description = props.description;
+    }
+}
+/** A 2d auxiliary coordinate system.
+ * @public
+ */
+export class AuxCoordSystem2d extends AuxCoordSystem {
+    static get className() { return "AuxCoordSystem2d"; }
+    origin;
+    angle;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.origin = props.origin ? Point2d.fromJSON(props.origin) : undefined;
+        this.angle = props.angle ? Angle.fromJSON(props.angle).degrees : undefined;
+    }
+    /** 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(BisCodeSpec.auxCoordSystem2d);
+        return new Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+}
+/** A 3d auxiliary coordinate system.
+ * @public
+ */
+export class AuxCoordSystem3d extends AuxCoordSystem {
+    static get className() { return "AuxCoordSystem3d"; }
+    origin;
+    yaw;
+    pitch;
+    roll;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.origin = props.origin ? Point3d.fromJSON(props.origin) : undefined;
+        this.yaw = props.yaw ? Angle.fromJSON(props.yaw).degrees : undefined;
+        this.pitch = props.pitch ? Angle.fromJSON(props.pitch).degrees : undefined;
+        this.roll = props.roll ? Angle.fromJSON(props.roll).degrees : undefined;
+    }
+    /** 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(BisCodeSpec.auxCoordSystem3d);
+        return new Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+}
+/** A spatial auxiliary coordinate system.
+ * @public
+ */
+export class AuxCoordSystemSpatial extends AuxCoordSystem3d {
+    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(BisCodeSpec.auxCoordSystemSpatial);
+        return new Code({ spec: codeSpec.id, scope: scopeModelId, value: codeValue });
+    }
+}
+/** Represents an *attachment* of a [[ViewDefinition]] to a [[Sheet]].
+ * @public
+ */
+export class ViewAttachment extends GraphicalElement2d {
+    static get className() { return "ViewAttachment"; }
+    view;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.view = new RelatedElement(props.view);
+        // ###NOTE: scale, displayPriority, and clipping vectors are stored in ViewAttachmentProps.jsonProperties.
+    }
+    collectReferenceIds(referenceIds) {
+        super.collectReferenceIds(referenceIds);
+        referenceIds.addElement(this.view.id);
+    }
+}
+/** The position in space of a Light.
+ * @internal
+ */
+export class LightLocation extends SpatialLocationElement {
+    static get className() { return "LightLocation"; }
+    /** Whether this light is currently turned on. */
+    enabled;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.enabled = props.enabled;
+    }
+}
+//# sourceMappingURL=ViewDefinition.js.map