/*---------------------------------------------------------------------------------------------
* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
* See LICENSE.md in the project root for license terms and full copyright notice.
*--------------------------------------------------------------------------------------------*/
/** @packageDocumentation
 * @module Elements
 */
import { IModel, RelatedElement, } from "@itwin/core-common";
import { InformationPartitionElement, RoleElement, TypeDefinitionElement } from "../Element";
import { RoleModel } from "../Model";
import { SubjectOwnsPartitionElements } from "../NavigationRelationship";
import { DrawingGraphicRepresentsElement, ElementRefersToElements } from "../Relationship";
import { EditTxn } from "../EditTxn";
import { _implicitTxn } from "../internal/Symbols";
/** A FunctionalPartition element is a key part of the iModel information hierarchy and is always parented
 * to a Subject and broken down by a FunctionalModel.
 * @public
 */
export class FunctionalPartition extends InformationPartitionElement {
    static get className() { return "FunctionalPartition"; }
    constructor(props, iModel) {
        super(props, iModel);
    }
}
/** A container for persisting FunctionalElements.
 * @public
 */
export class FunctionalModel extends RoleModel {
    static get className() { return "FunctionalModel"; }
    constructor(props, iModel) {
        super(props, iModel);
    }
    static insert(txnOrDb, parentSubjectId, name) {
        const txn = txnOrDb instanceof EditTxn ? txnOrDb : txnOrDb[_implicitTxn];
        const partitionId = txn.insertElement({
            classFullName: FunctionalPartition.classFullName,
            model: IModel.repositoryModelId,
            parent: new SubjectOwnsPartitionElements(parentSubjectId),
            code: FunctionalPartition.createCode(txn.iModel, parentSubjectId, name),
        });
        return txn.insertModel({
            classFullName: this.classFullName,
            modeledElement: { id: partitionId },
        });
    }
}
/** A FunctionalElement captures functional requirements that will ultimately be fulfilled by a PhysicalElement.
 * @public
 */
export class FunctionalElement extends RoleElement {
    static get className() { return "FunctionalElement"; }
    constructor(props, iModel) {
        super(props, iModel);
    }
}
/** A FunctionalBreakdownElement is a *folder* node in the functional hierarchy.
 * @public
 */
export class FunctionalBreakdownElement extends FunctionalElement {
    static get className() { return "FunctionalBreakdownElement"; }
    constructor(props, iModel) {
        super(props, iModel);
    }
}
/** @public */
export class FunctionalComposite extends FunctionalBreakdownElement {
    static get className() { return "FunctionalComposite"; }
    constructor(props, iModel) {
        super(props, iModel);
    }
}
/** A FunctionalComponentElement is a *leaf* node in the functional hierarchy.
 * @public
 */
export class FunctionalComponentElement extends FunctionalElement {
    static get className() { return "FunctionalComponentElement"; }
    constructor(props, iModel) {
        super(props, iModel);
    }
}
/** Defines a set of properties (the 'type') that can be associated with a Functional Element.
 * @public
 */
export class FunctionalType extends TypeDefinitionElement {
    static get className() { return "FunctionalType"; }
    constructor(props, iModel) {
        super(props, iModel);
    }
}
/** Relates a [[FunctionalElement]] to its [[FunctionalType]]
 * @public
 */
export class FunctionalElementIsOfType extends RelatedElement {
    static get className() { return "FunctionalElementIsOfType"; }
    static classFullName = "Functional:FunctionalElementIsOfType";
    constructor(id, relClassName = FunctionalElementIsOfType.classFullName) {
        super({ id, relClassName });
    }
}
/** Relates a [[PhysicalElement]] to the [[FunctionalElement]] elements that it fulfills.
 * @public
 */
export class PhysicalElementFulfillsFunction extends ElementRefersToElements {
    static get className() { return "PhysicalElementFulfillsFunction"; }
}
/** Relates a [[DrawingGraphic]] to the [[FunctionalElement]] that it represents
 * @public
 */
export class DrawingGraphicRepresentsFunctionalElement extends DrawingGraphicRepresentsElement {
    static get className() { return "DrawingGraphicRepresentsFunctionalElement"; }
}
//# sourceMappingURL=FunctionalElements.js.map