@itwin/linear-referencing-backend 5.0.0-dev.90 → 5.0.0-dev.93

package/lib/esm/LinearReferencingElements.js

@@ -0,0 +1,603 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module LinearReferencing
+ */
+import { assert, DbResult } from "@itwin/core-bentley";
+import { PhysicalElement, SpatialLocationElement } from "@itwin/core-backend";
+import { Code, IModelError, RelatedElement } from "@itwin/core-common";
+import { ComparisonOption, LinearlyReferencedLocationType, } from "@itwin/linear-referencing-common";
+import { LinearlyReferencedAtLocation, LinearlyReferencedFromToLocation } from "./LinearReferencingElementAspects.js";
+import { ILinearLocationLocatesElement, ILinearlyLocatedAlongILinearElement, IReferentReferencesElement, } from "./LinearReferencingRelationships.js";
+/** Base class for Spatial Location Element subclasses representing properties whose value is located along a Linear-Element and only applies to a portion of an Element.
+ * @beta
+ */
+export class LinearlyLocatedAttribution extends SpatialLocationElement {
+    /** @internal */
+    static get className() { return "LinearlyLocatedAttribution"; }
+    attributedElement;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.attributedElement = RelatedElement.fromJSON(props.attributedElement);
+    }
+    getLinearElementId() {
+        return LinearlyLocated.getLinearElementId(this.iModel, this.id);
+    }
+}
+/** Base class for Spatial Location Element implementations that are linearly located along a Linear-Element.
+ * @beta
+ */
+export class LinearLocationElement extends SpatialLocationElement {
+    /** @internal */
+    static get className() { return "LinearLocationElement"; }
+    constructor(props, iModel) {
+        super(props, iModel);
+    }
+    getLinearElementId() {
+        return LinearlyLocated.getLinearElementId(this.iModel, this.id);
+    }
+}
+/** Linear Referencing Location attached to an Element not inherently Linearly Referenced.
+ * @beta
+ */
+export class LinearLocation extends LinearLocationElement {
+    /** @internal */
+    static get className() { return "LinearLocation"; }
+    constructor(props, iModel) {
+        super(props, iModel);
+    }
+    static toProps(modelId, categoryId) {
+        const props = {
+            classFullName: LinearLocation.classFullName,
+            category: categoryId,
+            model: modelId,
+            code: Code.createEmpty(),
+        };
+        return props;
+    }
+    static create(iModel, modelId, categoryId) {
+        return new LinearLocation(this.toProps(modelId, categoryId), iModel);
+    }
+    static insertFromTo(iModel, modelId, categoryId, linearElementId, fromToPosition, locatedElementId) {
+        const newId = LinearlyLocated.insertFromTo(iModel, this.toProps(modelId, categoryId), linearElementId, fromToPosition);
+        ILinearLocationLocatesElement.insert(iModel, newId, locatedElementId);
+        return newId;
+    }
+    insertFromTo(iModel, linearElementId, fromToPosition, locatedElementId) {
+        const newId = LinearlyLocated.insertFromTo(iModel, this.toJSON(), linearElementId, fromToPosition);
+        ILinearLocationLocatesElement.insert(iModel, newId, locatedElementId);
+        return newId;
+    }
+    static insertAt(iModel, modelId, categoryId, linearElementId, atPosition, locatedElementId) {
+        const newId = LinearlyLocated.insertAt(iModel, this.toProps(modelId, categoryId), linearElementId, atPosition);
+        ILinearLocationLocatesElement.insert(iModel, newId, locatedElementId);
+        return newId;
+    }
+    insertAt(iModel, linearElementId, atPosition, locatedElementId) {
+        const newId = LinearlyLocated.insertAt(iModel, this.toJSON(), linearElementId, atPosition);
+        ILinearLocationLocatesElement.insert(iModel, newId, locatedElementId);
+        return newId;
+    }
+}
+/** Base class for Physical Elements that are inherently linearly located along a Linear-Element.
+ * @beta
+ */
+export class LinearPhysicalElement extends PhysicalElement {
+    /** @internal */
+    static get className() { return "LinearPhysicalElement"; }
+    constructor(props, iModel) {
+        super(props, iModel);
+    }
+}
+/** Spatial Location Element that can play the role of a Referent (known location along a Linear-Element).
+ * @beta
+ */
+export class ReferentElement extends SpatialLocationElement {
+    /** @internal */
+    static get className() { return "ReferentElement"; }
+    referencedElement;
+    constructor(props, iModel) {
+        super(props, iModel);
+        this.referencedElement = RelatedElement.fromJSON(props.referencedElement);
+    }
+    getLinearElementId() {
+        return LinearlyLocated.getLinearElementId(this.iModel, this.id);
+    }
+}
+/** Referent-implementation turning any bis:SpatialElement not inherently Linearly-Referenced into a Referent for Linear-Referencing purposes.
+ * @beta
+ */
+export class Referent extends ReferentElement {
+    /** @internal */
+    static get className() { return "Referent"; }
+    constructor(props, iModel) {
+        super(props, iModel);
+    }
+    static toProps(modelId, categoryId, referencedElementId) {
+        const props = {
+            classFullName: LinearLocation.classFullName,
+            category: categoryId,
+            model: modelId,
+            code: Code.createEmpty(),
+            referencedElement: new IReferentReferencesElement(referencedElementId),
+        };
+        return props;
+    }
+    static create(iModel, modelId, categoryId, referencedElementId) {
+        return new Referent(this.toProps(modelId, categoryId, referencedElementId), iModel);
+    }
+    static insertAt(iModel, modelId, categoryId, linearElementId, atPosition, referencedElementId) {
+        return LinearlyLocated.insertAt(iModel, this.toProps(modelId, categoryId, referencedElementId), linearElementId, atPosition);
+    }
+    insertAt(iModel, linearElementId, atPosition) {
+        return LinearlyLocated.insertAt(iModel, this.toJSON(), linearElementId, atPosition);
+    }
+}
+class ECSQLGenImpl {
+    selectDistinct() {
+        return false;
+    }
+}
+class AtAndFromToECSQLGenImpl extends ECSQLGenImpl {
+    genSelect() {
+        return "coalesce(AtLocation.AtPosition.DistanceAlongFromStart, FromToLocation.FromPosition.DistanceAlongFromStart) StartDistanceAlong, " +
+            "coalesce(AtLocation.AtPosition.DistanceAlongFromStart, FromToLocation.ToPosition.DistanceAlongFromStart) StopDistanceAlong, " +
+            "coalesce(AtLocation.ECInstanceId, FromToLocation.ECInstanceId) LocationAspectId ";
+    }
+    selectDistinct() {
+        return true;
+    }
+    genFromJoin() {
+        return "LEFT JOIN LinearReferencing.LinearlyReferencedAtLocation AtLocation ON LinearlyLocated.InstanceId = AtLocation.Element.Id " +
+            "LEFT JOIN LinearReferencing.LinearlyReferencedFromToLocation FromToLocation ON LinearlyLocated.InstanceId = FromToLocation.Element.Id ";
+    }
+    genWhere(bindVals, from, inclusiveFrom, to, inclusiveTo) {
+        const fromCompOp = (inclusiveFrom === undefined || inclusiveFrom) ? ">=" : ">";
+        const toCompOp = (inclusiveTo === undefined || inclusiveTo) ? "<=" : "<";
+        let ecSql = "";
+        if (from !== undefined && to !== undefined) {
+            ecSql += "(AtLocation.AtPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? AND AtLocation.AtPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ?) OR (FromToLocation.FromPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? AND FromToLocation.FromPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ?) " + "OR (FromToLocation.ToPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? AND FromToLocation.ToPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ?) OR (FromToLocation.FromPosition.DistanceAlongFromStart <= ? AND FromToLocation.ToPosition.DistanceAlongFromStart >= ?) ";
+            bindVals.push(from);
+            bindVals.push(to);
+            bindVals.push(from);
+            bindVals.push(to);
+            bindVals.push(from);
+            bindVals.push(to);
+            bindVals.push(from);
+            bindVals.push(to);
+        }
+        else if (from !== undefined) {
+            ecSql += "AtLocation.AtPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? OR FromToLocation.FromPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? OR FromToLocation.ToPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? ";
+            bindVals.push(from);
+            bindVals.push(from);
+            bindVals.push(from);
+        }
+        else if (to !== undefined) {
+            ecSql += "AtLocation.AtPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ? OR FromToLocation.FromPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ? OR FromToLocation.ToPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ? ";
+            bindVals.push(to);
+            bindVals.push(to);
+            bindVals.push(to);
+        }
+        else {
+            ecSql += "(AtLocation.AtPosition.DistanceAlongFromStart IS NOT NULL) OR ";
+            ecSql += "(FromToLocation.FromPosition.DistanceAlongFromStart IS NOT NULL) ";
+        }
+        return ecSql;
+    }
+    genOrderBy() {
+        return "coalesce(AtLocation.AtPosition.DistanceAlongFromStart, FromToLocation.FromPosition.DistanceAlongFromStart)";
+    }
+}
+class FromToECSQLGenImpl extends ECSQLGenImpl {
+    genSelect() {
+        return "FromToLocation.FromPosition.DistanceAlongFromStart StartDistanceAlong, FromToLocation.ToPosition.DistanceAlongFromStart StopDistanceAlong, FromToLocation.ECInstanceId LocationAspectId ";
+    }
+    genFromJoin() {
+        return "INNER JOIN LinearReferencing.LinearlyReferencedFromToLocation FromToLocation ON LinearlyLocated.InstanceId = FromToLocation.Element.Id ";
+    }
+    genWhere(bindVals, from, inclusiveFrom, to, inclusiveTo) {
+        const fromCompOp = (inclusiveFrom === undefined || inclusiveFrom) ? ">=" : ">";
+        const toCompOp = (inclusiveTo === undefined || inclusiveTo) ? "<=" : "<";
+        let ecSql = "";
+        if (from !== undefined && to !== undefined) {
+            ecSql += "AND ((FromToLocation.FromPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? AND FromToLocation.FromPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ?) OR (FromToLocation.ToPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? AND FromToLocation.ToPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ?) OR (FromToLocation.FromPosition.DistanceAlongFromStart <= ? AND FromToLocation.ToPosition.DistanceAlongFromStart >= ?)) ";
+            bindVals.push(from);
+            bindVals.push(to);
+            bindVals.push(from);
+            bindVals.push(to);
+            bindVals.push(from);
+            bindVals.push(to);
+        }
+        else if (from !== undefined) {
+            ecSql += "AND (FromToLocation.FromPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? OR FromToLocation.ToPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ?)";
+            bindVals.push(from);
+            bindVals.push(from);
+        }
+        else if (to !== undefined) {
+            ecSql += "AND (FromToLocation.FromPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ? OR FromToLocation.ToPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ?) ";
+            bindVals.push(to);
+            bindVals.push(to);
+        }
+        else {
+            ecSql += "FromToLocation.FromPosition.DistanceAlongFromStart IS NOT NULL ";
+        }
+        return ecSql;
+    }
+    genOrderBy() {
+        return "FromToLocation.FromPosition.DistanceAlongFromStart";
+    }
+}
+class AtECSQLGenImpl extends ECSQLGenImpl {
+    genSelect() {
+        return "AtLocation.AtPosition.DistanceAlongFromStart StartDistanceAlong, AtLocation.AtPosition.DistanceAlongFromStart StopDistanceAlong, AtLocation.ECInstanceId LocationAspectId ";
+    }
+    genFromJoin() {
+        return "INNER JOIN LinearReferencing.LinearlyReferencedAtLocation AtLocation ON LinearlyLocated.InstanceId = AtLocation.Element.Id ";
+    }
+    genWhere(bindVals, from, inclusiveFrom, to, inclusiveTo) {
+        const fromCompOp = (inclusiveFrom === undefined || inclusiveFrom) ? ">=" : ">";
+        const toCompOp = (inclusiveTo === undefined || inclusiveTo) ? "<=" : "<";
+        let ecSql = "";
+        if (from !== undefined && to !== undefined) {
+            ecSql += "AtLocation.AtPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? AND AtLocation.AtPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ? ";
+            bindVals.push(from);
+            bindVals.push(to);
+        }
+        else if (from !== undefined) {
+            ecSql += "AtLocation.AtPosition.DistanceAlongFromStart ";
+            ecSql += fromCompOp;
+            ecSql += " ? ";
+            bindVals.push(from);
+        }
+        else if (to !== undefined) {
+            ecSql += "AtLocation.AtPosition.DistanceAlongFromStart ";
+            ecSql += toCompOp;
+            ecSql += " ? ";
+            bindVals.push(to);
+        }
+        else
+            ecSql += "AtLocation.AtPosition.DistanceAlongFromStart IS NOT NULL ";
+        return ecSql;
+    }
+    genOrderBy() {
+        return "AtLocation.AtPosition.DistanceAlongFromStart";
+    }
+}
+class QueryLinearLocationsECSQLGen {
+    _params;
+    _ecSql;
+    _addSelectClause(impl) {
+        let select = "SELECT ";
+        if (impl.selectDistinct())
+            select += "DISTINCT ";
+        select += "LinearlyLocated.InstanceId LinearlyLocatedId, printf('%s:%s', meta.ECSchemaDef.Name, meta.ECClassDef.Name) LinearlyLocatedClassFullName, ";
+        select += impl.genSelect();
+        this._ecSql += select;
+    }
+    _parseClassFullName(classFullName) {
+        const parts = classFullName.split(":");
+        if (parts.length !== 2)
+            return undefined;
+        return [parts[0], parts[1]];
+    }
+    _genLinearlyLocated() {
+        return "meta.ECSchemaDef JOIN meta.ECClassDef USING meta.SchemaOwnsClasses JOIN " +
+            "(SELECT coalesce(Located.TargetECInstanceId, Along.SourceECInstanceId) InstanceId, " +
+            "coalesce(Located.TargetECClassId, Along.SourceECClassId) ClassId " +
+            "FROM LinearReferencing.ILinearlyLocatedAlongILinearElement Along LEFT JOIN " +
+            "LinearReferencing.ILinearLocationLocatesElement Located ON Along.SourceECInstanceId = Located.SourceECInstanceId " +
+            "WHERE Along.TargetECInstanceId = ?) LinearlyLocated ON meta.ECClassDef.ECInstanceId = LinearlyLocated.ClassId ";
+    }
+    _addFromClause(impl /* bvector<double>& bindVals */) {
+        let from = "FROM ";
+        from += this._genLinearlyLocated();
+        from += impl.genFromJoin();
+        this._ecSql += from;
+    }
+    _addWhereClause(impl, bindVals) {
+        let where = "WHERE ";
+        where += impl.genWhere(bindVals, this._params.fromDistanceAlong, (this._params.fromComparisonOption === undefined ||
+            this._params.fromComparisonOption === ComparisonOption.Inclusive), this._params.toDistanceAlong, (this._params.toComparisonOption === undefined ||
+            this._params.toComparisonOption === ComparisonOption.Inclusive));
+        if (this._params.linearlyLocatedClassFullNames !== undefined) {
+            if (where.length > 6)
+                where += "AND ";
+            if (1 === this._params.linearlyLocatedClassFullNames.length) {
+                const classFullName = this._params.linearlyLocatedClassFullNames[0];
+                const schemaNameClassName = this._parseClassFullName(classFullName);
+                if (schemaNameClassName === undefined)
+                    throw new IModelError(0, "Invalid full class name");
+                where += `meta.ECSchemaDef.Name='${schemaNameClassName[0]}' AND meta.ECClassDef.Name='${schemaNameClassName[1]}' `;
+            }
+            else if (1 < this._params.linearlyLocatedClassFullNames.length) {
+                where += "(";
+                for (const classFullName of this._params.linearlyLocatedClassFullNames) {
+                    if (classFullName === undefined)
+                        continue;
+                    const schemaNameClassName = this._parseClassFullName(classFullName);
+                    if (schemaNameClassName === undefined)
+                        continue;
+                    where += `(meta.ECSchemaDef.Name='${schemaNameClassName[0]}' AND meta.ECClassDef.Name='${schemaNameClassName[1]}') OR `;
+                }
+                where = where.substring(0, where.length - 4); // Removing last OR
+                where += ") ";
+            }
+        }
+        this._ecSql += where;
+    }
+    _addOrderByClause(impl) {
+        let orderBy = "ORDER BY ";
+        orderBy += impl.genOrderBy();
+        this._ecSql += orderBy;
+    }
+    _createImpl() {
+        if (this._params.linearlyReferencedLocationTypeFilter === undefined ||
+            this._params.linearlyReferencedLocationTypeFilter === LinearlyReferencedLocationType.Any) {
+            return new AtAndFromToECSQLGenImpl();
+        }
+        else if (this._params.linearlyReferencedLocationTypeFilter === LinearlyReferencedLocationType.FromTo) {
+            return new FromToECSQLGenImpl();
+        }
+        else {
+            return new AtECSQLGenImpl();
+        }
+    }
+    constructor(params) {
+        this._params = params;
+        this._ecSql = "";
+    }
+    generate(linearElementId) {
+        this._ecSql = "";
+        const impl = this._createImpl();
+        const bindVals = [linearElementId];
+        this._addSelectClause(impl);
+        this._addFromClause(impl);
+        this._addWhereClause(impl, bindVals);
+        this._addOrderByClause(impl);
+        return [this._ecSql, bindVals];
+    }
+}
+/** A class offering services for LinearlyLocated elements.
+ * @beta
+ */
+export class LinearlyLocated {
+    static insertBasic(iModel, elProps, linearElementId) {
+        const newId = iModel.elements.insertElement(elProps);
+        const linearlyLocatedAlongLinearElement = ILinearlyLocatedAlongILinearElement.create(iModel, newId, linearElementId);
+        linearlyLocatedAlongLinearElement.insert();
+        return newId;
+    }
+    /** Insert a new LinearlyLocated element into an iModel at a specific location along an existing Linear-Element.
+     * @param iModel The iModel to insert the new element into.
+     * @param elProps The properties of the new element.
+     * @param linearElementId The Id of the Linear-Element along which the new LinearlyLocated will be inserted.
+     * @param atPosition Linear position.
+     * @returns The newly inserted element's Id.
+     * @throws [[IModelError]] if unable to insert the element.
+     */
+    static insertAt(iModel, elProps, linearElementId, atPosition) {
+        const newId = this.insertBasic(iModel, elProps, linearElementId);
+        LinearlyReferencedAtLocation.insert(iModel, newId, atPosition.atPosition, (atPosition.fromReferent === undefined) ? undefined : atPosition.fromReferent.id);
+        return newId;
+    }
+    /** Insert a new LinearlyLocated element into an iModel at a specific from-to location along an existing Linear-Element.
+     * @param iModel The iModel to insert the new element into.
+     * @param elProps The properties of the new element.
+     * @param linearElementId The Id of the Linear-Element along which the new LinearlyLocated will be inserted.
+     * @param fromToPosition Linear position.
+     * @returns The newly inserted element's Id.
+     * @throws [[IModelError]] if unable to insert the element.
+     */
+    static insertFromTo(iModel, elProps, linearElementId, fromToPosition) {
+        const newId = this.insertBasic(iModel, elProps, linearElementId);
+        LinearlyReferencedFromToLocation.insert(iModel, newId, fromToPosition.fromPosition, fromToPosition.toPosition, (fromToPosition.fromPositionFromReferent === undefined) ? undefined : fromToPosition.fromPositionFromReferent.id, (fromToPosition.toPositionFromReferent === undefined) ? undefined : fromToPosition.toPositionFromReferent.id);
+        return newId;
+    }
+    static getLinearLocations(iModel, linearlyLocatedElementId, fullClassName) {
+        const aspects = iModel.elements.getAspects(linearlyLocatedElementId, fullClassName);
+        if (aspects.length === 0)
+            return [];
+        const retVal = [];
+        for (const aspect of aspects) {
+            const linearAspect = aspect;
+            retVal.push(linearAspect);
+        }
+        return retVal;
+    }
+    static queryFirstLinearLocationAspectId(iModel, linearlyLocatedElementId, className) {
+        let aspectId;
+        iModel.withPreparedStatement(`SELECT ECInstanceId FROM LinearReferencing.${className} WHERE Element.Id=? LIMIT 1`, (stmt) => {
+            stmt.bindId(1, linearlyLocatedElementId);
+            if (stmt.step() === DbResult.BE_SQLITE_ROW)
+                aspectId = stmt.getValue(0).getId();
+        });
+        return aspectId;
+    }
+    /** Query for LinearlyReferenced AtLocation aspects owned by the specified LinearlyLocated Element.
+     * @param iModel The iModel to query from.
+     * @param linearlyLocatedElementId The id of the LinearlyLocated Element to query aspects about.
+     * @returns Returns an array of LinearlyReferencedAtLocation.
+     * @throws [[IModelError]]
+     */
+    static getAtLocations(iModel, linearlyLocatedElementId) {
+        return this.getLinearLocations(iModel, linearlyLocatedElementId, "LinearReferencing:LinearlyReferencedAtLocation");
+    }
+    /** Query for the single LinearlyReferenced AtLocation aspect owned by the specified LinearlyLocated Element. If more than one aspect is expected, use [[getAtLocations]] instead.
+     * @param iModel The iModel to query from.
+     * @param linearlyLocatedElementId The id of the LinearlyLocated Element to query about.
+     * @returns Returns an LinearlyReferencedAtLocation or undefined is none is found.
+     * @throws [[IModelError]]
+     */
+    static getAtLocation(iModel, linearlyLocatedElementId) {
+        const linearLocations = this.getAtLocations(iModel, linearlyLocatedElementId);
+        if (linearLocations.length === 0)
+            return undefined;
+        else {
+            assert(linearLocations.length === 1);
+            return linearLocations[0];
+        }
+    }
+    /** Update an existing LinearlyReferencedAtLocation aspect within the iModel.
+     * @param iModel The iModel to update.
+     * @param linearlyLocatedElementId The Id of the owning Linearly Located Element.
+     * @param linearLocationProps The properties to use to update the LinearlyReferencedAtLocation aspect.
+     * @param aspectId The Id of the aspect to update. If not known, the first aspectId will be looked-up.
+     * @throws [[IModelError]]
+     */
+    static updateAtLocation(iModel, linearlyLocatedElementId, linearLocationProps, aspectId) {
+        let linearLocAspectId;
+        if (aspectId !== undefined)
+            linearLocAspectId = aspectId;
+        else {
+            linearLocAspectId = this.queryFirstLinearLocationAspectId(iModel, linearlyLocatedElementId, "LinearlyReferencedAtLocation");
+        }
+        const linearLocationAspectProps = {
+            id: linearLocAspectId,
+            element: { id: linearlyLocatedElementId },
+            classFullName: "LinearReferencing:LinearlyReferencedAtLocation",
+            atPosition: linearLocationProps.atPosition,
+            fromReferent: linearLocationProps.fromReferent,
+        };
+        iModel.elements.updateAspect(linearLocationAspectProps);
+    }
+    /** Update an existing LinearlyReferencedFromToLocation aspect within the iModel.
+     * @param iModel The iModel to update.
+     * @param linearlyLocatedElementId The Id of the owning Linearly Located Element.
+     * @param linearLocationProps The properties to use to update the LinearlyReferencedFromToLocation aspect.
+     * @param aspectId The Id of the aspect to update. If not known, the first aspectId will be looked-up.
+     * @throws [[IModelError]]
+     */
+    static updateFromToLocation(iModel, linearlyLocatedElementId, linearLocationProps, aspectId) {
+        let linearLocAspectId;
+        if (aspectId !== undefined)
+            linearLocAspectId = aspectId;
+        else {
+            linearLocAspectId = this.queryFirstLinearLocationAspectId(iModel, linearlyLocatedElementId, "LinearlyReferencedFromToLocation");
+        }
+        const linearLocationAspectProps = {
+            id: linearLocAspectId,
+            element: { id: linearlyLocatedElementId, relClassName: "LinearReferencing:ILinearlyLocatedOwnsFromToLocations" },
+            classFullName: "LinearReferencing:LinearlyReferencedFromToLocation",
+            fromPosition: linearLocationProps.fromPosition,
+            fromPositionFromReferent: linearLocationProps.fromPositionFromReferent,
+            toPosition: linearLocationProps.toPosition,
+            toPositionFromReferent: linearLocationProps.toPositionFromReferent,
+        };
+        iModel.elements.updateAspect(linearLocationAspectProps);
+    }
+    /** Query for the Id of the Linear-Element along which the specified LinearlyLocated Element is located.
+     * @param iModel The iModel to query from.
+     * @param linearlyLocatedElementId The id of the LinearlyLocated Element to query a Linear-Element for.
+     * @returns Returns the Id of the Linear-Element or undefined is none is assigned.
+     */
+    static getLinearElementId(iModel, linearlyLocatedElementId) {
+        let linearElementId;
+        iModel.withPreparedStatement("SELECT TargetECInstanceId FROM LinearReferencing.ILinearlyLocatedAlongILinearElement WHERE SourceECInstanceId = ?", (stmt) => {
+            stmt.bindId(1, linearlyLocatedElementId);
+            if (DbResult.BE_SQLITE_ROW === stmt.step())
+                linearElementId = stmt.getValue(0).getId();
+            else
+                linearElementId = undefined;
+        });
+        return linearElementId;
+    }
+    /** Query for LinearlyReferenced FromToLocation aspects owned by the specified LinearlyLocated Element.
+     * @param iModel The iModel to query from.
+     * @param linearlyLocatedElementId The id of the LinearlyLocated Element to query aspects about.
+     * @returns Returns an array of LinearlyReferencedFromToLocation.
+     * @throws [[IModelError]]
+     */
+    static getFromToLocations(iModel, linearlyLocatedElementId) {
+        return this.getLinearLocations(iModel, linearlyLocatedElementId, "LinearReferencing:LinearlyReferencedFromToLocation");
+    }
+    /** Query for the single LinearlyReferenced FromToLocation aspect owned by the specified LinearlyLocated Element. If more than one aspect is expected, use [[getFromToLocations]] instead.
+     * @param iModel The iModel to query from.
+     * @param linearlyLocatedElementId The id of the LinearlyLocated Element to query about.
+     * @returns Returns an LinearlyReferencedFromToLocation or undefined is none is found.
+     * @throws [[IModelError]]
+     */
+    static getFromToLocation(iModel, linearlyLocatedElementId) {
+        const linearLocations = this.getFromToLocations(iModel, linearlyLocatedElementId);
+        if (linearLocations.length === 0)
+            return undefined;
+        else {
+            assert(linearLocations.length === 1);
+            return linearLocations[0];
+        }
+    }
+}
+/** A class offering services for linearly-located data along a Linear-Element.
+ * @beta
+ */
+export class LinearElement {
+    /** Query for LinearLocationReferences based on specified query parameters.
+     * @returns Returns an array of LinearLocationReferences.
+     * @throws [[IModelError]]
+     */
+    static queryLinearLocations(iModel, linearElementId, queryParams) {
+        const ecSqlGen = new QueryLinearLocationsECSQLGen(queryParams);
+        const ecsqlAndBindVals = ecSqlGen.generate(linearElementId);
+        const linearLocationRefs = [];
+        iModel.withPreparedStatement(ecsqlAndBindVals[0], (stmt) => {
+            stmt.bindValues(ecsqlAndBindVals[1]);
+            while (DbResult.BE_SQLITE_ROW === stmt.step()) {
+                const linearLocationRef = {
+                    linearlyLocatedId: stmt.getValue(0).getId(),
+                    linearlyLocatedClassFullName: stmt.getValue(1).getString(),
+                    startDistanceAlong: stmt.getValue(2).getDouble(),
+                    stopDistanceAlong: stmt.getValue(3).getDouble(),
+                    locationAspectId: stmt.getValue(4).getId(),
+                };
+                linearLocationRefs.push(linearLocationRef);
+            }
+        });
+        return linearLocationRefs;
+    }
+}
+//# sourceMappingURL=LinearReferencingElements.js.map