@sap/artifact-management 1.25.0 → 1.26.0

package/dist/src/plugins/cap/readers/calculation-view/model/model.js

@@ -0,0 +1,858 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementRefFilter = exports.ValueRange = exports.SimpleType = exports.Element = exports.Input = exports.Mapping = exports.MappingType = exports.ExceptionAggregationBehavior = exports.AggregationBehavior = exports.TemporalCondition = exports.Join = exports.ViewNode = exports.ViewModel = exports.ColumnView = exports.Order = exports.UDFParameter = exports.Parameter = exports.Entity = exports.SortDirection = exports.ExpressionLanguage = exports.SemanticType = exports.MeasureType = exports.PrimitiveType = exports.ViewNodeType = exports.OutputType = exports.JoinType = exports.HierarchyFunction = exports.EntityType = exports.DataCategory = void 0;
+const modelbase_1 = __importStar(require("./modelbase"));
+const sharedmodel_1 = require("./sharedmodel");
+var DataCategory;
+(function (DataCategory) {
+    DataCategory["DEFAULT"] = "DEFAULT";
+    DataCategory["DIMENSION"] = "DIMENSION";
+    DataCategory["CUBE"] = "CUBE";
+    DataCategory["FACT"] = "FACT";
+    DataCategory["TEXT"] = "TEXT";
+    DataCategory["HIERARCHY"] = "HIERARCHY";
+})(DataCategory = exports.DataCategory || (exports.DataCategory = {}));
+;
+var EntityType;
+(function (EntityType) {
+    // For catalog types value is same as in DataSourceType enumeration in XSD;
+    // For DT objects value is same as file suffix
+    EntityType["DATABASE_VIEW"] = "DATA_BASE_VIEW";
+    EntityType["DATABASE_TABLE"] = "DATA_BASE_TABLE";
+    EntityType["ATTRIBUTE_VIEW"] = "ATTRIBUTEVIEW";
+    EntityType["ANALYTIC_VIEW"] = "ANALYTICVIEW";
+    EntityType["CALCULATION_VIEW"] = "CALCULATIONVIEW";
+    EntityType["TABLE_FUNCTION"] = "hdbtablefunction";
+    EntityType["SCALAR_FUNCTION"] = "hdbscalarfunction";
+    EntityType["PROCEDURE"] = "hdbprocedure";
+    EntityType["CATALOG_PROCEDURE"] = "procedure";
+    EntityType["GRAPH_WORKSPACE"] = "GRAPH_WORKSPACE";
+})(EntityType = exports.EntityType || (exports.EntityType = {}));
+;
+var HierarchyFunction;
+(function (HierarchyFunction) {
+    HierarchyFunction["HIERARCHY"] = "HIERARCHY";
+    HierarchyFunction["HIERARCHY_LEVELED"] = "HIERARCHY_LEVELED";
+    HierarchyFunction["HIERARCHY_TEMPORAL"] = "HIERARCHY_TEMPORAL";
+    HierarchyFunction["HIERARCHY_SPANTREE"] = "HIERARCHY_SPANTREE";
+    HierarchyFunction["HIERARCHY_DESCENDANTS"] = "HIERARCHY_DESCENDANTS";
+    HierarchyFunction["HIERARCHY_ANCESTORS"] = "HIERARCHY_ANCESTORS";
+    HierarchyFunction["HIERARCHY_SIBLINGS"] = "HIERARCHY_SIBLINGS";
+})(HierarchyFunction = exports.HierarchyFunction || (exports.HierarchyFunction = {}));
+;
+var JoinType;
+(function (JoinType) {
+    JoinType["REFERENTIAL"] = "referential";
+    JoinType["INNER"] = "inner";
+    JoinType["LEFT_OUTER"] = "leftOuter";
+    JoinType["RIGHT_OUTER"] = "rightOuter";
+    JoinType["FULL_OUTER"] = "fullOuter";
+    JoinType["TEXT_TABLE"] = "textTable";
+})(JoinType = exports.JoinType || (exports.JoinType = {}));
+;
+var OutputType;
+(function (OutputType) {
+    OutputType["Vertices"] = "vertices";
+    OutputType["Edges"] = "edges";
+})(OutputType = exports.OutputType || (exports.OutputType = {}));
+var ViewNodeType;
+(function (ViewNodeType) {
+    ViewNodeType["JoinNode"] = "JoinNode";
+    ViewNodeType["Projection"] = "Projection";
+    ViewNodeType["Aggregation"] = "Aggregation";
+    ViewNodeType["Rank"] = "Rank";
+    ViewNodeType["WindowFunction"] = "WindowFunction";
+    ViewNodeType["Union"] = "Union";
+    ViewNodeType["Script"] = "Script";
+    ViewNodeType["Graph"] = "Graph";
+    ViewNodeType["Intersect"] = "Intersect";
+    ViewNodeType["Minus"] = "Minus";
+    ViewNodeType["TableFunction"] = "TableFunction";
+    ViewNodeType["Hierarchy"] = "Hierarchy";
+    ViewNodeType["NonEquiJoinNode"] = "NonEquiJoinNode";
+    ViewNodeType["Anonymize"] = "Anonymize";
+})(ViewNodeType = exports.ViewNodeType || (exports.ViewNodeType = {}));
+var PrimitiveType;
+(function (PrimitiveType) {
+    PrimitiveType["VARCHAR"] = "VARCHAR";
+    PrimitiveType["NVARCHAR"] = "NVARCHAR";
+    PrimitiveType["TINYINT"] = "TINYINT";
+    PrimitiveType["SMALLINT"] = "SMALLINT";
+    PrimitiveType["INTEGER"] = "INTEGER";
+    PrimitiveType["BIGINT"] = "BIGINT";
+    PrimitiveType["DECIMAL"] = "DECIMAL";
+    PrimitiveType["REAL"] = "REAL";
+    PrimitiveType["FLOAT"] = "FLOAT";
+    PrimitiveType["DOUBLE"] = "DOUBLE";
+    PrimitiveType["SMALLDECIMAL"] = "SMALLDECIMAL";
+    PrimitiveType["NUMERIC"] = "NUMERIC";
+    PrimitiveType["BOOLEAN"] = "BOOLEAN";
+    PrimitiveType["BLOB"] = "BLOB";
+    PrimitiveType["NCLOB"] = "NCLOB";
+    PrimitiveType["VARBINARY"] = "VARBINARY";
+    PrimitiveType["DATE"] = "DATE";
+    PrimitiveType["SECONDDATE"] = "SECONDDATE";
+    PrimitiveType["TIME"] = "TIME";
+    PrimitiveType["TIMESTAMP"] = "TIMESTAMP";
+})(PrimitiveType = exports.PrimitiveType || (exports.PrimitiveType = {}));
+var MeasureType;
+(function (MeasureType) {
+    MeasureType["RESTRICTION"] = "restriction";
+    MeasureType["COUNTER"] = "counter";
+    MeasureType["CALCULATED_MEASURE"] = "calculatedMeasure";
+})(MeasureType = exports.MeasureType || (exports.MeasureType = {}));
+var SemanticType;
+(function (SemanticType) {
+    SemanticType["EMPTY"] = "empty";
+    SemanticType["AMOUNT"] = "amount";
+    SemanticType["QUANTITY"] = "quantity";
+    // CURRENCY_CODE = "Currency",
+    SemanticType["CURRENCY_CODE"] = "currencyCode";
+    // UNIT_OF_MEASURE = "UnitOfMeasure",
+    SemanticType["UNIT_OF_MEASURE"] = "unitOfMeasure";
+    SemanticType["TIME"] = "time";
+    // DATE = "Date",
+    SemanticType["DATE"] = "date";
+    /*DATE_BUSINESS_DATE_FROM = "dateBusinessDateFrom",
+DATE_BUSINESS_DATE_TO = "dateBusinessDateTo",
+GEO_LOCATION_LONGITUDE = "geoLocationLongitude",
+GEO_LOCATION_LATITUDE = "geoLocationLatitude",
+GEO_LOCATION_CARTO_ID = "geoLocationCartoId",
+GEO_LOCATION_NORMALIZED_NAME = "geoLocationNormalizedName",*/
+    SemanticType["DATE_BUSINESS_DATE_FROM"] = "date.businessDateFrom";
+    SemanticType["DATE_BUSINESS_DATE_TO"] = "date.businessDateTo";
+    SemanticType["GEO_LOCATION_LONGITUDE"] = "geoLocation.longitude";
+    SemanticType["GEO_LOCATION_LATITUDE"] = "geoLocation.latitude";
+    SemanticType["GEO_LOCATION_CARTO_ID"] = "geoLocation.cartoId";
+    SemanticType["GEO_LOCATION_NORMALIZED_NAME"] = "geoLocation.normalizedName";
+    SemanticType["CLIENT"] = "client";
+    SemanticType["LANGUAGE"] = "language";
+    SemanticType["DESCRIPTION"] = "description";
+    SemanticType["HYPERLINK"] = "hyperlink";
+})(SemanticType = exports.SemanticType || (exports.SemanticType = {}));
+;
+var ExpressionLanguage;
+(function (ExpressionLanguage) {
+    ExpressionLanguage["COLUMN_ENGINE"] = "COLUMN_ENGINE";
+    ExpressionLanguage["SQL"] = "SQL";
+})(ExpressionLanguage = exports.ExpressionLanguage || (exports.ExpressionLanguage = {}));
+;
+var SortDirection;
+(function (SortDirection) {
+    SortDirection["ASC"] = "ASC";
+    SortDirection["DESC"] = "DESC";
+})(SortDirection = exports.SortDirection || (exports.SortDirection = {}));
+;
+class SortAttribute extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+}
+class Expression extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.formula = '';
+        this.$setAttributes(attributes, skippedNodes);
+    }
+}
+class Entity extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.$$keyAttributeName = 'id';
+        this.name = '';
+        this.isLoadFromXML = false;
+        this.elements = new modelbase_1.ModelCollection(this, 'elements', true);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    createElement(attributes, skippedNodes, nextElementName) {
+        const element = this.elements.get(attributes.name);
+        if (element) {
+            throw new modelbase_1.ObjectAlreadyExistsException(this, attributes.name, this.name);
+        }
+        return this.createOrMergeElement(attributes, skippedNodes, nextElementName);
+    }
+    createOrMergeElement(attributes, skippedNodes, nextElementName) {
+        let element = this.elements.get(attributes.name);
+        if (element) {
+            element.$setAttributes(attributes, skippedNodes);
+        }
+        else {
+            element = new Element(attributes, skippedNodes);
+            if (nextElementName) {
+                this.elements.addValueNextKey(element, nextElementName);
+            }
+            else {
+                this.elements.addValue(element);
+            }
+        }
+        return element;
+    }
+}
+exports.Entity = Entity;
+class Parameter extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.$$keyAttributeName = 'name';
+        this.isVariable = false;
+        this._fuzzySimilarity = new modelbase_1.SingleValueContainer(this, '', true);
+        this.assignedElements = new modelbase_1.ModelCollection(this, 'assignedElements', false);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+}
+exports.Parameter = Parameter;
+class UDFParameter extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this._element = new modelbase_1.SingleValueContainer(this, 'element', false);
+        this._parameter = new modelbase_1.SingleValueContainer(this, 'parameter', false);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    get element() {
+        return this._element.get();
+    }
+    set element(value) {
+        this._element.set(value);
+    }
+    get parameter() {
+        return this._parameter.get();
+    }
+    set parameter(value) {
+        this._parameter.set(value);
+    }
+}
+exports.UDFParameter = UDFParameter;
+class Order extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this._byElement = new modelbase_1.SingleValueContainer(this, 'byElement', false);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    get byElement() {
+        return this._byElement.get();
+    }
+    set byElement(value) {
+        this._byElement.set(value);
+    }
+}
+exports.Order = Order;
+class ColumnView extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.parameters = new modelbase_1.ModelCollection(this, 'parameters', true);
+        this.viewNodes = new modelbase_1.ModelCollection(this, 'viewNodes', true);
+        this._defaultNodeElementInstancesArray = [];
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    createViewNode(attributes, skippedNodes, isDefaultNode = false) {
+        const viewNode = this.viewNodes.get(attributes.name);
+        if (viewNode) {
+            throw new modelbase_1.ObjectAlreadyExistsException(this, attributes.name, this.id);
+        }
+        return this.createOrMergeViewNode(attributes, skippedNodes, isDefaultNode);
+    }
+    createOrMergeViewNode(attributes, skippedNodes, isDefaultNode) {
+        let viewNode = this.viewNodes.get(attributes.name);
+        if (viewNode) {
+            viewNode.$setAttributes(attributes, skippedNodes);
+        }
+        else {
+            viewNode = new ViewNode(attributes, skippedNodes);
+            this.viewNodes.addValue(viewNode);
+        }
+        if (isDefaultNode) {
+            this.setDefaultNode(viewNode);
+        }
+        return viewNode;
+    }
+    createParameter(attributes, skippedNodes) {
+        const parameter = new Parameter(attributes, skippedNodes);
+        this.parameters.addValue(parameter);
+        return parameter;
+    }
+    getDefaultNode() {
+        return this._defaultNode;
+    }
+    setDefaultNode(viewNode) {
+        if (viewNode) {
+            if (this._defaultNode) {
+                throw new modelbase_1.ModelException('default node already set');
+            }
+            {
+                viewNode._isDefaultNode = true;
+            }
+        }
+        this._defaultNode = viewNode;
+    }
+}
+exports.ColumnView = ColumnView;
+;
+class ViewModel extends modelbase_1.default.AbstractModel {
+    constructor() {
+        super();
+        this._columnView = new modelbase_1.SingleValueContainer(this, 'columnView', true);
+        this._entities = new modelbase_1.ModelCollection(this, '_entities', true);
+        this.referenceEntities = new modelbase_1.ModelCollection(this, 'referenceEntities', false);
+    }
+    get columnView() {
+        const value = this._columnView.get();
+        return value;
+    }
+    set columnView(value) {
+        this._columnView.set(value);
+    }
+    createColumnView(attributes, skippedNodes) {
+        const columnView = new ColumnView(attributes, skippedNodes);
+        this.columnView = columnView;
+        return columnView;
+    }
+    createEntity(attributes, skippedNodes) {
+        const entity = new Entity(attributes, skippedNodes);
+        const key = entity.$getKeyAttributeValue();
+        if (this._entities.get(key)) {
+            entity.$rename(this._entities.getUniqueKey(key));
+        }
+        this._entities.addValue(entity);
+        return entity;
+    }
+}
+exports.ViewModel = ViewModel;
+;
+class ViewNode extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.$$keyAttributeName = 'name';
+        this._isDefaultNode = false;
+        this.name = '';
+        this.useDimensionViewHierarchies = false;
+        this._filterExpression = new modelbase_1.SingleValueContainer(this, 'filterExpression', true);
+        this.inputs = new modelbase_1.ModelCollection(this, 'inputs', true);
+        this.elements = new modelbase_1.ModelCollection(this, 'elements', true);
+        this.joins = new modelbase_1.ModelCollection(this, 'joins', true);
+        this._rankingFilter = new modelbase_1.SingleValueContainer(this, 'rankingFilter', true);
+        this._windowFunction = new modelbase_1.SingleValueContainer(this, 'windowFunction', true);
+        this.sortAttributes = new modelbase_1.ModelCollection(this, 'sortAttributes', true);
+        this.viewAttributeKeys = {};
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    get filterExpression() {
+        return this._filterExpression.get();
+    }
+    set filterExpression(value) {
+        this._filterExpression.set(value);
+    }
+    get rankingFilter() {
+        return this._rankingFilter.get();
+    }
+    set rankingFilter(value) {
+        this._rankingFilter.set(value);
+    }
+    get windowFunction() {
+        return this._windowFunction.get();
+    }
+    set windowFunction(value) {
+        this._windowFunction.set(value);
+    }
+    $getContainer() {
+        return super.$getContainer();
+    }
+    createInput(attributes, skippedNodes) {
+        const input = new Input(attributes, skippedNodes);
+        this.inputs.addValue(input);
+        return input;
+    }
+    createElementWithoutAddingIntoElementCollection(attributes, skippedNodes) {
+        let element = this.elements.get(attributes.name);
+        if (element) {
+            throw new modelbase_1.ObjectAlreadyExistsException(this, attributes.name, this.name);
+        }
+        else {
+            element = new Element(attributes, skippedNodes);
+        }
+        return element;
+    }
+    createOrMergeElement(attributes, skippedNodes) {
+        let element = this.elements.get(attributes.name);
+        if (element) {
+            element.$setAttributes(attributes, skippedNodes);
+        }
+        else {
+            element = new Element(attributes, skippedNodes);
+            this.elements.addValue(element);
+        }
+        return element;
+    }
+    createJoin(attributes, skippedNodes) {
+        const join = new Join(attributes, skippedNodes);
+        this.joins.addValue(join);
+        return join;
+    }
+    createSortAttributes(attributes, skippedNodes) {
+        const sortAttribute = new SortAttribute(attributes, skippedNodes);
+        this.sortAttributes.addValue(sortAttribute);
+        return sortAttribute;
+    }
+    createFilterExpression(attributes, skippedNodes) {
+        this.filterExpression = new Expression(attributes, skippedNodes);
+        return this.filterExpression;
+    }
+    createRankFilter(attributes, skippedNodes) {
+        this.rankingFilter = new RankFilter(attributes, skippedNodes);
+        return this.rankingFilter;
+    }
+    createWindowFunction(attributes, skippedNodes) {
+        this.windowFunction = new WindowFunction(attributes, skippedNodes);
+        return this.windowFunction;
+    }
+    isDefaultNode() {
+        return this._isDefaultNode;
+    }
+    isScriptNode() {
+        return this.type === ViewNodeType.Script;
+    }
+    isJoinNode() {
+        return this.type === ViewNodeType.JoinNode;
+    }
+    isStarJoin() {
+        return this.isJoinNode() && this.isDefaultNode();
+    }
+    getDefaultInput() {
+        if (!this.isDefaultNode()) {
+            throw new modelbase_1.ModelException('Default input cannot be determined for {0}, it is not the default node', this);
+        }
+        let result;
+        this.inputs.foreach(function (input) {
+            result = input;
+            // should be only one input
+            return;
+        });
+        return result;
+    }
+    getAllMappingsOfViewNode() {
+        const allMappings = {};
+        if (this.inputs && this.inputs._keys.length > 0) {
+            let mapping;
+            const inputs = this.inputs;
+            for (let i = 0; i < inputs.count(); i++) {
+                const input = inputs.getAt(i);
+                for (let j = 0; j < input.mappings.count(); j++) {
+                    mapping = input.mappings.getAt(j);
+                    if (mapping.type !== MappingType.ConstantElementMapping &&
+                        mapping.targetElement && mapping.targetElement.name) {
+                        // allMappings[input.name][mapping.targetElement.name] = mapping;
+                        allMappings[mapping.targetElement.name] = {
+                            'mapping': mapping,
+                            'input': input,
+                        };
+                    }
+                }
+            }
+        }
+        return allMappings;
+    }
+}
+exports.ViewNode = ViewNode;
+class RankFilter extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.rankViewAttributeName = '';
+        this.orders = new modelbase_1.ModelCollection(this, 'orders', true);
+        this._rankThreshold = new modelbase_1.SingleValueContainer(this, 'rankThreshold', true);
+        this.partitionElements = new modelbase_1.ModelCollection(this, 'partitionElements', false);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    get rankThreshold() {
+        return this._rankThreshold.get();
+    }
+    set rankThreshold(value) {
+        this._rankThreshold.set(value);
+    }
+    createOrMergeRankThreshold(attributes, skippedNodes) {
+        let threshold = this.rankThreshold;
+        if (threshold) {
+            threshold.$setAttributes(attributes, skippedNodes);
+        }
+        else {
+            threshold = new UDFParameter(attributes, skippedNodes);
+            this.rankThreshold = threshold;
+        }
+        return this.rankThreshold;
+    }
+    createOrder(attributes, skippedNodes) {
+        const order = new Order(attributes, skippedNodes);
+        this.orders.addValue(order);
+        return order;
+    }
+}
+class WindowFunction extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.functionArguments = [];
+        this.orderAttributes = new modelbase_1.ModelCollection(this, 'orderAttributes', true);
+        this.partitionAttributes = new modelbase_1.ModelCollection(this, 'partitionAttributes', false);
+        this._resultElement = new modelbase_1.SingleValueContainer(this, 'resultElement', false);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    get resultElement() {
+        return this._resultElement.get();
+    }
+    set resultElement(value) {
+        this._resultElement.set(value);
+    }
+    createOrder(attributes, skippedNodes) {
+        const orderAttribute = new Order(attributes, skippedNodes);
+        this.orderAttributes.addValue(orderAttribute);
+        return orderAttribute;
+    }
+}
+class Join extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this._temporalJoinProperties = new modelbase_1.SingleValueContainer(this, 'temporalJoinProperties', true);
+        this._leftInput = new modelbase_1.SingleValueContainer(this, 'leftInput', false);
+        this._rightInput = new modelbase_1.SingleValueContainer(this, 'rightInput', false);
+        this.leftElements = new modelbase_1.ModelCollection(this, 'leftElements', false);
+        this.rightElements = new modelbase_1.ModelCollection(this, 'rightElements', false);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    get temporalJoinProperties() {
+        return this._temporalJoinProperties.get();
+    }
+    set temporalJoinProperties(value) {
+        this._temporalJoinProperties.set(value);
+    }
+    get leftInput() {
+        return this._leftInput.get();
+    }
+    set leftInput(value) {
+        this._leftInput.set(value);
+    }
+    get rightInput() {
+        return this._rightInput.get();
+    }
+    set rightInput(value) {
+        this._rightInput.set(value);
+    }
+    createTemporalJoinProperties(attributes, skippedNodes) {
+        const temporalJoinProperties = new TemporalJoinProperties(attributes, skippedNodes);
+        this.temporalJoinProperties = temporalJoinProperties;
+        return this.temporalJoinProperties;
+    }
+}
+exports.Join = Join;
+class TemporalJoinProperties extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this._temporalElement = new modelbase_1.SingleValueContainer(this, 'temporalElement', false);
+        this._fromElement = new modelbase_1.SingleValueContainer(this, 'fromElement', false);
+        this._toElement = new modelbase_1.SingleValueContainer(this, 'toElement', false);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    get temporalElement() {
+        return this._temporalElement.get();
+    }
+    set temporalElement(value) {
+        this._temporalElement.set(value);
+    }
+    get fromElement() {
+        return this._fromElement.get();
+    }
+    set fromElement(value) {
+        this._fromElement.set(value);
+    }
+    get toElement() {
+        return this._toElement.get();
+    }
+    set toElement(value) {
+        this._toElement.set(value);
+    }
+}
+;
+var TemporalCondition;
+(function (TemporalCondition) {
+    TemporalCondition["INCLUDE_TO_EXCLUDE_FROM"] = "INCLUDE_TO_EXCLUDE_FROM";
+    TemporalCondition["EXCLUDE_TO_INCLUDE_FROM"] = "EXCLUDE_TO_INCLUDE_FROM";
+    TemporalCondition["EXCLUDE_BOTH"] = "EXCLUDE_BOTH";
+    TemporalCondition["INCLUDE_BOTH"] = "INCLUDE_BOTH";
+})(TemporalCondition = exports.TemporalCondition || (exports.TemporalCondition = {}));
+;
+var AggregationBehavior;
+(function (AggregationBehavior) {
+    // Name same as in AggregationBehavior enumeration in datamodel.type XSD
+    // Value same as in AggregationType enumeration in bimodel.cube XSD for easy conversion
+    AggregationBehavior["NONE"] = "none";
+    AggregationBehavior["SUM"] = "sum";
+    AggregationBehavior["MIN"] = "min";
+    AggregationBehavior["MAX"] = "max";
+    AggregationBehavior["COUNT"] = "count";
+    AggregationBehavior["FORMULA"] = "formula";
+})(AggregationBehavior = exports.AggregationBehavior || (exports.AggregationBehavior = {}));
+;
+var ExceptionAggregationBehavior;
+(function (ExceptionAggregationBehavior) {
+    ExceptionAggregationBehavior["COUNT_DISTINCT"] = "countDistinct";
+})(ExceptionAggregationBehavior = exports.ExceptionAggregationBehavior || (exports.ExceptionAggregationBehavior = {}));
+;
+var MappingType;
+(function (MappingType) {
+    MappingType["ElementMapping"] = "ElementMapping";
+    MappingType["ConstantElementMapping"] = "ConstantElementMapping";
+    MappingType["InputMapping"] = "InputMapping";
+})(MappingType = exports.MappingType || (exports.MappingType = {}));
+;
+class Mapping extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super({}, skippedNodes);
+        this._targetElement = new modelbase_1.SingleValueContainer(this, 'targetElement', false);
+        this._sourceElement = new modelbase_1.SingleValueContainer(this, 'sourceElement', false);
+        this._sourceInput = new modelbase_1.SingleValueContainer(this, 'sourceInput', false);
+        const { 
+        // these 3 variable should not be put in `attributes`
+        targetElement, sourceElement, sourceInput, ...attr } = attributes;
+        this.targetElement = targetElement !== null && targetElement !== void 0 ? targetElement : null;
+        this.sourceElement = sourceElement !== null && sourceElement !== void 0 ? sourceElement : null;
+        this.sourceInput = sourceInput !== null && sourceInput !== void 0 ? sourceInput : null;
+        this.$setAttributes(attr, skippedNodes);
+    }
+    get targetElement() {
+        return this._targetElement.get();
+    }
+    set targetElement(value) {
+        this._targetElement.set(value);
+    }
+    get sourceElement() {
+        return this._sourceElement.get();
+    }
+    set sourceElement(value) {
+        this._sourceElement.set(value);
+    }
+    get sourceInput() {
+        return this._sourceInput.get();
+    }
+    set sourceInput(value) {
+        this._sourceInput.set(value);
+    }
+}
+exports.Mapping = Mapping;
+class Input extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.alias = '';
+        this.repositoryInputNodeId = '';
+        this.selectAll = false;
+        this.mappings = new modelbase_1.ModelCollection(this, 'mappings', true);
+        this._source = null;
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    getSource() {
+        return this._source;
+    }
+    setSource(source) {
+        this._source = source;
+        return this._source;
+    }
+    createMapping(attributes, skippedNodes) {
+        const mapping = new Mapping(attributes, skippedNodes);
+        this.mappings.addValue(mapping);
+        return mapping;
+    }
+}
+exports.Input = Input;
+class Element extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.$$keyAttributeName = 'name';
+        this.name = '';
+        this.generatedColumn = false;
+        this.restrictions = new modelbase_1.ModelCollection(this, 'restrictions', true);
+        this._restrictionExpression = new modelbase_1.SingleValueContainer(this, 'restrictionExpression', true);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+    get restrictionExpression() {
+        return this._restrictionExpression.get();
+    }
+    set restrictionExpression(value) {
+        this._restrictionExpression.set(value);
+    }
+    createOrMergeSimpleType(attributes, skippedNodes) {
+        let simpleType = this.inlineType;
+        if (simpleType) {
+            simpleType.$setAttributes(attributes, skippedNodes);
+        }
+        else {
+            simpleType = new SimpleType(attributes, skippedNodes);
+            this.inlineType = simpleType;
+        }
+        return simpleType;
+    }
+    getMapping() {
+        let mapping;
+        const targetName = this.name;
+        let mappingFound = false;
+        const inputs = this.$getContainer().inputs;
+        for (let i = 0; i < inputs.count(); i++) {
+            const input = inputs.getAt(i);
+            for (let j = 0; j < input.mappings.count(); j++) {
+                mapping = input.mappings.getAt(j);
+                if (mapping.targetElement && mapping.targetElement.name === targetName) {
+                    mappingFound = true;
+                    break;
+                }
+            }
+        }
+        if (mappingFound) {
+            return mapping;
+        }
+    }
+    createDefaultMapping(attributes, skippedNodes) {
+        if (this.$getContainer() && !this.$getContainer().isDefaultNode()) {
+            throw new modelbase_1.ModelException('Default mapping cannot be created for {0}, its parent {1} is not the default node', [this, this.$getContainer()]);
+        }
+        // remember skipped nodes
+        this.$setAttributes(null, skippedNodes);
+        let mapping = null;
+        if (this.$getContainer() && !this.$getContainer().isScriptNode()) {
+            const input = this.$getContainer().getDefaultInput();
+            // mapping = input.createMapping(attributes);
+            // : passing skippedNodes to be used by renderer
+            mapping = input.createMapping(attributes, skippedNodes);
+        }
+        return mapping;
+    }
+    createCalculationDefinition(attributes) {
+        this.calculationDefinition = new Expression(attributes);
+        return this.calculationDefinition;
+    }
+    createRestriction(attributes, skippedNodes) {
+        const restriction = new ElementRefFilter(attributes, skippedNodes);
+        this.restrictions.addValue(restriction);
+        return restriction;
+    }
+    createRestrictionExpression(attributes) {
+        this.restrictionExpression = new Expression(attributes);
+        return this.restrictionExpression;
+    }
+    isCalculatedColumn() {
+        if (this.calculationDefinition) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    isRestrictedColumn() {
+        if (this.measureType === MeasureType.RESTRICTION) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    isHierarchyGererated() {
+        const viewNode = this.$getContainer();
+        if (viewNode.type !== ViewNodeType.Hierarchy) {
+            throw new modelbase_1.UnsupportedOperationException(this);
+        }
+        if (viewNode.hierarchyFunction === HierarchyFunction.HIERARCHY ||
+            viewNode.hierarchyFunction === HierarchyFunction.HIERARCHY_LEVELED ||
+            viewNode.hierarchyFunction === HierarchyFunction.HIERARCHY_SPANTREE ||
+            viewNode.hierarchyFunction === HierarchyFunction.HIERARCHY_TEMPORAL) {
+            if (this.name === 'HIERARCHY_RANK' ||
+                this.name === 'HIERARCHY_TREE_SIZE' ||
+                this.name === 'HIERARCHY_PARENT_RANK' ||
+                this.name === 'HIERARCHY_LEVEL' ||
+                this.name === 'HIERARCHY_IS_CYCLE' ||
+                this.name === 'HIERARCHY_IS_ORPHAN') {
+                return true;
+            }
+            if (viewNode.hierarchyFunction === HierarchyFunction.HIERARCHY_LEVELED) {
+                if (this.name === 'HIERARCHY_LEVEL_NAME' ||
+                    this.name === 'PARENT_ID' ||
+                    this.name === 'NODE_ID') {
+                    return true;
+                }
+            }
+        }
+        if (viewNode.hierarchyFunction === HierarchyFunction.HIERARCHY_ANCESTORS ||
+            viewNode.hierarchyFunction === HierarchyFunction.HIERARCHY_DESCENDANTS) {
+            if (this.name === 'HIERARCHY_DISTANCE') {
+                return true;
+            }
+        }
+        if (viewNode.hierarchyFunction === HierarchyFunction.HIERARCHY_ANCESTORS ||
+            viewNode.hierarchyFunction === HierarchyFunction.HIERARCHY_DESCENDANTS) {
+            if (this.name === 'HIERARCHY_SIBLING_DISTANCE') {
+                return true;
+            }
+        }
+    }
+}
+exports.Element = Element;
+class SimpleType extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.length = undefined; //short int
+        this.precision = undefined; //short int
+        this.scale = undefined; //short int
+        this.semanticType = undefined;
+        this.isDerived = false;
+        this.presentationScale = undefined; //short int
+        this.valueRanges = new modelbase_1.ModelCollection(this, 'valueRange', true);
+        this.$setAttributes(attributes, skippedNodes);
+    }
+}
+exports.SimpleType = SimpleType;
+class ValueRange extends modelbase_1.AbstractModelClass {
+    constructor(attributes, skippedNodes) {
+        super(attributes, skippedNodes);
+        this.$$keyAttributeName = 'value';
+        this.value = '';
+        this.$setAttributes(attributes, skippedNodes);
+    }
+}
+exports.ValueRange = ValueRange;
+/**
+ * @class ElementRefFilter - Similar to ElementFilter; but this one contains object based reference to Element
+ * @property {Element} element - Element reference
+ * @property {ModelCollection} valueFilters - Collection of objects of type sharedmodel.ValueFilter
+ */
+class ElementRefFilter extends modelbase_1.AbstractModelClass {
+    constructor() {
+        super(...arguments);
+        this.type = 'AttributeFilter';
+        this.valueFilters = new modelbase_1.ModelCollection(this, 'valueFilters', true);
+        this._element = new modelbase_1.SingleValueContainer(this, 'element', false);
+    }
+    get element() {
+        return this._element.get();
+    }
+    set element(value) {
+        this._element.set(value);
+    }
+    createValueFilter(attributes, skippedNodes) {
+        const valueFilter = new sharedmodel_1.ValueFilter(attributes, skippedNodes);
+        this.valueFilters.addValue(valueFilter);
+        return valueFilter;
+    }
+}
+exports.ElementRefFilter = ElementRefFilter;
+//# sourceMappingURL=model.js.map