@sap/artifact-management-types 1.25.0 → 1.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/artifact-management-types",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "Type signatures for artifact management",
   "types": "./src/index.d.ts",
   "main": "./src/index.d.ts",
@@ -10,7 +10,7 @@
     "pack": "npm run modify-types-import && npm pack"
   },
   "dependencies": {
-    "@sap/artifact-management-base-types": "1.25.0"
+    "@sap/artifact-management-base-types": "1.26.0"
   },
   "devDependencies": {
     "gulp": "4.0.2"

package/src/cp/CFProjectBuilder.d.ts

@@ -54,5 +54,5 @@ export default class CFProjectBuilder implements ProjectBuilder {
     private generateOverviewApplication;
     private generateURLFromMetadataService;
     private generateURLFromHtml5RepoService;
-    private addDestinationForMtx;
+    private modifyMtx;
 }

package/src/plugins/cap/readers/calculation-view/CalculationViewItemReader.d.ts

@@ -0,0 +1,33 @@
+import { Item, ProjectEntityReaderReadOptions, ProjectFileSystem } from '@sap/artifact-management-base-types';
+import { ViewModel, Element, EntityType } from './model/model';
+export default class CalculationViewItemReader {
+    private static readonly itemTags;
+    private parseBaseMeasureColumns;
+    private parseCalculatedMeasureColumns;
+    private parseRestrictedMeasureColumns;
+    private parseCalculatedColumns;
+    private parseDataSourceColumns;
+    private parseDataSources;
+    private getExposedColumns;
+    private getParsedXML;
+    private getNameAndNamespace;
+    getDetails({ fs, matchedFiles }: ProjectEntityReaderReadOptions): Promise<Item[]>;
+    static getDetail(fs: ProjectFileSystem, filePath: string): Promise<ViewModel | null>;
+    static viewModelToItem(viewModel: ViewModel, file: string): Item;
+}
+export declare const ProxyResolver: {
+    resolve(fs: ProjectFileSystem, rootModel: ViewModel, isAssociation: boolean): Promise<void[]>;
+    _resolveEntities(fs: ProjectFileSystem, rootModel: ViewModel, isAssociation: boolean): Promise<void[]>;
+};
+export declare class ProjectApiGeneralReader {
+    static getDetailByName(fs: ProjectFileSystem, entityName: string): Promise<{
+        type: EntityType;
+        columns: Element[];
+    } | null>;
+    private static getCdsEntityDetail;
+    static getCalculationViewDetail(fs: ProjectFileSystem, entityName: string): Promise<{
+        type: EntityType;
+        columns: Element[];
+    } | null>;
+    private static getCalculationViewFile;
+}

package/src/plugins/cap/readers/calculation-view/model/XmlReader.d.ts

@@ -0,0 +1,38 @@
+interface Node {
+    nextSibling: any;
+}
+export default class XmlReader {
+    documentProperties: any;
+    _xmlDocument: Node;
+    _hasMovedDown: boolean;
+    _current: Node | null;
+    skippedNodes: any;
+    _skippedNodesStack: any[];
+    _removePrefixFunctions: any;
+    _isRead: boolean;
+    context: any;
+    private checkParserError;
+    private parseDocument;
+    private detectLineEndings;
+    private createDocumentProperties;
+    private fixLineEndings;
+    private _getParentSkippedNodes;
+    removePrefix(namespace: string, value: any): any;
+    private _tryMoveTo;
+    tryMoveTo(name: string, namespace?: string, match?: any): boolean;
+    tryMoveToIntermediate(name: string, namespace?: string, match?: any): boolean;
+    moveToIntermediate(name: string, namespace?: string, match?: any): this;
+    moveTo(name: string, namespace?: string, match?: any): this;
+    tryMoveDown(): boolean;
+    moveUp(): XmlReader;
+    moveDown(): this;
+    skipChildren(): this;
+    next(): this;
+    buildAttributes(attributeMapping: any, existingProperties?: any): any;
+    getAttribute(name: string, namespace?: string): string | null;
+    consumeAttribute(name: string, namespace?: string): string | null;
+    getContent(): any;
+    consumeContent(): any;
+    constructor(xmlDocument: string | Node, fixMixedLineEndings: string, forceLineEndings: boolean);
+}
+export {};

package/src/plugins/cap/readers/calculation-view/model/common.d.ts

@@ -0,0 +1,44 @@
+interface ChildNode {
+}
+interface Node {
+}
+export default abstract class Util {
+    private static XSI_NS;
+    private static XML_NS;
+    private static XMLNS_PREFIX;
+    static XMLNS_REGEX: RegExp;
+    static SELECTOR_REGEX: RegExp;
+    private static createSelectorNS;
+    static isMSXML(): boolean;
+    static parseInt(value: string): number;
+    static parseBool(value: string): boolean;
+    static createIntSelector(name: string): object;
+    static createBoolSelector(name: string): object;
+    static createSelector(name: string, valueMapper: any): object;
+    static createXsiSelector(name: string, valueMapper: any): object;
+    static parseSelector(selector: any): any;
+}
+export declare class SkippedNodes {
+    nodeName: string | undefined;
+    xmlnsAttributes: any[];
+    attributes: object;
+    attributeNames: any[];
+    nodesBefore: Node[];
+    childNodes: ChildNode[];
+    nodesAfter: any[];
+    intermediateElements: object;
+    constructor(nodeName?: string);
+}
+export declare class DocumentProperties {
+    detectedLineEndings: string;
+    hasMixedLineEndings: boolean;
+    spacesBeforeDocumentElement: string;
+    spacesAfterDocumentElement: string;
+}
+export declare class XmlReaderException extends Error {
+    message: string;
+    name: string;
+    constructor(node: Node | null | undefined, message: string);
+    toString(): string;
+}
+export {};

package/src/plugins/cap/readers/calculation-view/model/model.d.ts

@@ -0,0 +1,401 @@
+import modelbase, { ModelCollection, AbstractModelClass, WritableCalcViewModel } from './modelbase';
+import { ValueFilter } from './sharedmodel';
+export declare enum DataCategory {
+    DEFAULT = "DEFAULT",
+    DIMENSION = "DIMENSION",
+    CUBE = "CUBE",
+    FACT = "FACT",
+    TEXT = "TEXT",
+    HIERARCHY = "HIERARCHY"
+}
+export declare enum EntityType {
+    DATABASE_VIEW = "DATA_BASE_VIEW",
+    DATABASE_TABLE = "DATA_BASE_TABLE",
+    ATTRIBUTE_VIEW = "ATTRIBUTEVIEW",
+    ANALYTIC_VIEW = "ANALYTICVIEW",
+    CALCULATION_VIEW = "CALCULATIONVIEW",
+    TABLE_FUNCTION = "hdbtablefunction",
+    SCALAR_FUNCTION = "hdbscalarfunction",
+    PROCEDURE = "hdbprocedure",
+    CATALOG_PROCEDURE = "procedure",
+    GRAPH_WORKSPACE = "GRAPH_WORKSPACE"
+}
+export declare enum HierarchyFunction {
+    HIERARCHY = "HIERARCHY",
+    HIERARCHY_LEVELED = "HIERARCHY_LEVELED",
+    HIERARCHY_TEMPORAL = "HIERARCHY_TEMPORAL",
+    HIERARCHY_SPANTREE = "HIERARCHY_SPANTREE",
+    HIERARCHY_DESCENDANTS = "HIERARCHY_DESCENDANTS",
+    HIERARCHY_ANCESTORS = "HIERARCHY_ANCESTORS",
+    HIERARCHY_SIBLINGS = "HIERARCHY_SIBLINGS"
+}
+export declare enum JoinType {
+    REFERENTIAL = "referential",
+    INNER = "inner",
+    LEFT_OUTER = "leftOuter",
+    RIGHT_OUTER = "rightOuter",
+    FULL_OUTER = "fullOuter",
+    TEXT_TABLE = "textTable"
+}
+export declare enum OutputType {
+    Vertices = "vertices",
+    Edges = "edges"
+}
+export declare enum ViewNodeType {
+    JoinNode = "JoinNode",
+    Projection = "Projection",
+    Aggregation = "Aggregation",
+    Rank = "Rank",
+    WindowFunction = "WindowFunction",
+    Union = "Union",
+    Script = "Script",
+    Graph = "Graph",
+    Intersect = "Intersect",
+    Minus = "Minus",
+    TableFunction = "TableFunction",
+    Hierarchy = "Hierarchy",
+    NonEquiJoinNode = "NonEquiJoinNode",
+    Anonymize = "Anonymize"
+}
+export declare enum PrimitiveType {
+    VARCHAR = "VARCHAR",
+    NVARCHAR = "NVARCHAR",
+    TINYINT = "TINYINT",
+    SMALLINT = "SMALLINT",
+    INTEGER = "INTEGER",
+    BIGINT = "BIGINT",
+    DECIMAL = "DECIMAL",
+    REAL = "REAL",
+    FLOAT = "FLOAT",
+    DOUBLE = "DOUBLE",
+    SMALLDECIMAL = "SMALLDECIMAL",
+    NUMERIC = "NUMERIC",
+    BOOLEAN = "BOOLEAN",
+    BLOB = "BLOB",
+    NCLOB = "NCLOB",
+    VARBINARY = "VARBINARY",
+    DATE = "DATE",
+    SECONDDATE = "SECONDDATE",
+    TIME = "TIME",
+    TIMESTAMP = "TIMESTAMP"
+}
+export declare enum MeasureType {
+    RESTRICTION = "restriction",
+    COUNTER = "counter",
+    CALCULATED_MEASURE = "calculatedMeasure"
+}
+export declare enum SemanticType {
+    EMPTY = "empty",
+    AMOUNT = "amount",
+    QUANTITY = "quantity",
+    CURRENCY_CODE = "currencyCode",
+    UNIT_OF_MEASURE = "unitOfMeasure",
+    TIME = "time",
+    DATE = "date",
+    DATE_BUSINESS_DATE_FROM = "date.businessDateFrom",
+    DATE_BUSINESS_DATE_TO = "date.businessDateTo",
+    GEO_LOCATION_LONGITUDE = "geoLocation.longitude",
+    GEO_LOCATION_LATITUDE = "geoLocation.latitude",
+    GEO_LOCATION_CARTO_ID = "geoLocation.cartoId",
+    GEO_LOCATION_NORMALIZED_NAME = "geoLocation.normalizedName",
+    CLIENT = "client",
+    LANGUAGE = "language",
+    DESCRIPTION = "description",
+    HYPERLINK = "hyperlink"
+}
+export declare enum ExpressionLanguage {
+    COLUMN_ENGINE = "COLUMN_ENGINE",
+    SQL = "SQL"
+}
+export declare enum SortDirection {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+declare class SortAttribute extends AbstractModelClass<SortAttribute> {
+    id: string;
+    direction: SortDirection;
+    constructor(attributes: WritableCalcViewModel<SortAttribute>, skippedNodes: any);
+}
+declare class Expression extends AbstractModelClass<Expression> {
+    formula: string;
+    expressionLanguage: ExpressionLanguage;
+    constructor(attributes: WritableCalcViewModel<Expression>, skippedNodes?: any);
+}
+export declare class Entity extends AbstractModelClass<Entity> {
+    protected readonly $$keyAttributeName = "id";
+    name: string;
+    id: string;
+    type: EntityType;
+    isProxy: boolean;
+    isLoadFromXML: boolean;
+    readonly elements: ModelCollection<Element>;
+    constructor(attributes: any, skippedNodes: any);
+    createElement(attributes: WritableCalcViewModel<Element> & {
+        name: string;
+    }, skippedNodes?: any, nextElementName?: string): Element;
+    createOrMergeElement(attributes: WritableCalcViewModel<Element> & {
+        name: string;
+    }, skippedNodes?: any, nextElementName?: string): Element;
+}
+export declare class Parameter extends AbstractModelClass<Parameter> {
+    protected $$keyAttributeName: string;
+    name: string;
+    isVariable: boolean;
+    private readonly _fuzzySimilarity;
+    readonly assignedElements: ModelCollection<Element>;
+    constructor(attributes: WritableCalcViewModel<Parameter> & {
+        name: string;
+    }, skippedNodes: any);
+}
+export declare class UDFParameter extends AbstractModelClass<UDFParameter> {
+    private readonly _element;
+    private readonly _parameter;
+    constructor(attributes: any, skippedNodes: any);
+    get element(): Element | null;
+    set element(value: Element | null);
+    get parameter(): Parameter | null;
+    set parameter(value: Parameter | null);
+}
+export declare class Order extends AbstractModelClass<Order> {
+    private readonly _byElement;
+    constructor(attributes: any, skippedNodes: any);
+    get byElement(): Element;
+    set byElement(value: Element);
+}
+export declare class ColumnView extends AbstractModelClass<ColumnView> {
+    id: string;
+    dataCategory: DataCategory;
+    readonly parameters: ModelCollection<Parameter>;
+    readonly viewNodes: ModelCollection<ViewNode>;
+    _defaultNode: ViewNode;
+    _defaultNodeElementInstancesArray: Element[];
+    constructor(attributes: any, skippedNodes: any);
+    createViewNode(attributes: WritableCalcViewModel<ViewNode> & {
+        name: string;
+    }, skippedNodes: any, isDefaultNode?: boolean): ViewNode;
+    createOrMergeViewNode(attributes: WritableCalcViewModel<ViewNode> & {
+        name: string;
+    }, skippedNodes: any, isDefaultNode?: boolean): ViewNode;
+    createParameter(attributes: WritableCalcViewModel<Parameter> & {
+        name: string;
+    }, skippedNodes: any): Parameter;
+    getDefaultNode(): ViewNode;
+    setDefaultNode(viewNode: ViewNode): void;
+}
+export declare class ViewModel extends modelbase.AbstractModel {
+    private readonly _columnView;
+    readonly _entities: ModelCollection<Entity>;
+    readonly referenceEntities: ModelCollection<Entity>;
+    constructor();
+    get columnView(): ColumnView;
+    set columnView(value: ColumnView);
+    createColumnView(attributes: any, skippedNodes: any): ColumnView;
+    createEntity(attributes: any, skippedNodes?: any): Entity;
+}
+export declare class ViewNode extends AbstractModelClass<ViewNode> {
+    protected readonly $$keyAttributeName = "name";
+    _isDefaultNode: boolean;
+    name: string;
+    type: ViewNodeType;
+    action?: any;
+    useDimensionViewHierarchies: boolean;
+    hierarchyFunction?: HierarchyFunction;
+    private readonly _filterExpression;
+    readonly inputs: ModelCollection<Input>;
+    readonly elements: ModelCollection<Element>;
+    readonly joins: ModelCollection<Join>;
+    private readonly _rankingFilter;
+    private readonly _windowFunction;
+    readonly sortAttributes: ModelCollection<SortAttribute>;
+    viewAttributeKeys: any;
+    constructor(attributes: WritableCalcViewModel<ViewNode>, skippedNodes: any);
+    get filterExpression(): Expression | null;
+    set filterExpression(value: Expression | null);
+    get rankingFilter(): RankFilter | null;
+    set rankingFilter(value: RankFilter | null);
+    get windowFunction(): WindowFunction | null;
+    set windowFunction(value: WindowFunction | null);
+    $getContainer(): ColumnView;
+    createInput(attributes: WritableCalcViewModel<Input>, skippedNodes: any): Input;
+    createElementWithoutAddingIntoElementCollection(attributes: WritableCalcViewModel<Element> & {
+        name: string;
+    }, skippedNodes?: any): Element;
+    createOrMergeElement(attributes: WritableCalcViewModel<Element> & {
+        name: string;
+    }, skippedNodes: any): Element;
+    createJoin(attributes: WritableCalcViewModel<Join>, skippedNodes: any): Join;
+    createSortAttributes(attributes: WritableCalcViewModel<SortAttribute>, skippedNodes: any): SortAttribute;
+    createFilterExpression(attributes: WritableCalcViewModel<Expression>, skippedNodes: any): Expression;
+    createRankFilter(attributes: WritableCalcViewModel<RankFilter>, skippedNodes?: any): RankFilter;
+    createWindowFunction(attributes: WritableCalcViewModel<WindowFunction>, skippedNodes?: any): WindowFunction;
+    isDefaultNode(): boolean;
+    isScriptNode(): boolean;
+    isJoinNode(): boolean;
+    isStarJoin(): boolean;
+    getDefaultInput(): Input | undefined;
+    getAllMappingsOfViewNode(): {
+        [key: string]: {
+            mapping: Mapping;
+            input: Input;
+        };
+    };
+}
+declare class RankFilter extends AbstractModelClass<RankFilter> {
+    type: string;
+    offset: string;
+    offsetParameter: string;
+    offsetReference: string;
+    dynamicPartitionElements: boolean;
+    rankViewAttributeName: string;
+    readonly orders: ModelCollection<Order>;
+    private readonly _rankThreshold;
+    readonly partitionElements: ModelCollection<Element>;
+    constructor(attributes: WritableCalcViewModel<RankFilter>, skippedNodes: any);
+    get rankThreshold(): UDFParameter | null;
+    set rankThreshold(value: UDFParameter | null);
+    createOrMergeRankThreshold(attributes: WritableCalcViewModel<UDFParameter>, skippedNodes: any): UDFParameter | null;
+    createOrder(attributes: WritableCalcViewModel<Order>, skippedNodes: any): Order;
+}
+declare class WindowFunction extends AbstractModelClass<WindowFunction> {
+    name: string;
+    functionArguments: string[];
+    readonly orderAttributes: ModelCollection<Order>;
+    readonly partitionAttributes: ModelCollection<Element>;
+    private readonly _resultElement;
+    constructor(attributes: any, skippedNodes: any);
+    get resultElement(): Element | null;
+    set resultElement(value: Element | null);
+    createOrder(attributes: WritableCalcViewModel<Order>, skippedNodes?: any): Order;
+}
+export declare class Join extends AbstractModelClass<Join> {
+    joinType: JoinType;
+    private readonly _temporalJoinProperties;
+    private readonly _leftInput;
+    private readonly _rightInput;
+    readonly leftElements: ModelCollection<Element>;
+    readonly rightElements: ModelCollection<Element>;
+    constructor(attributes: any, skippedNodes: any);
+    get temporalJoinProperties(): TemporalJoinProperties | null;
+    set temporalJoinProperties(value: TemporalJoinProperties | null);
+    get leftInput(): Input | null;
+    set leftInput(value: Input | null);
+    get rightInput(): Input | null;
+    set rightInput(value: Input | null);
+    createTemporalJoinProperties(attributes: WritableCalcViewModel<TemporalJoinProperties>, skippedNodes?: any): TemporalJoinProperties;
+}
+declare class TemporalJoinProperties extends AbstractModelClass<TemporalJoinProperties> {
+    temporalCondition: TemporalCondition;
+    private readonly _temporalElement;
+    private readonly _fromElement;
+    private readonly _toElement;
+    constructor(attributes: WritableCalcViewModel<TemporalJoinProperties>, skippedNodes: any);
+    get temporalElement(): Element | null;
+    set temporalElement(value: Element | null);
+    get fromElement(): Element | null;
+    set fromElement(value: Element | null);
+    get toElement(): Element | null;
+    set toElement(value: Element | null);
+}
+export declare enum TemporalCondition {
+    INCLUDE_TO_EXCLUDE_FROM = "INCLUDE_TO_EXCLUDE_FROM",
+    EXCLUDE_TO_INCLUDE_FROM = "EXCLUDE_TO_INCLUDE_FROM",
+    EXCLUDE_BOTH = "EXCLUDE_BOTH",
+    INCLUDE_BOTH = "INCLUDE_BOTH"
+}
+export declare enum AggregationBehavior {
+    NONE = "none",
+    SUM = "sum",
+    MIN = "min",
+    MAX = "max",
+    COUNT = "count",
+    FORMULA = "formula"
+}
+export declare enum ExceptionAggregationBehavior {
+    COUNT_DISTINCT = "countDistinct"
+}
+export declare enum MappingType {
+    ElementMapping = "ElementMapping",
+    ConstantElementMapping = "ConstantElementMapping",
+    InputMapping = "InputMapping"
+}
+export declare class Mapping extends AbstractModelClass<Mapping> {
+    type: MappingType;
+    private readonly _targetElement;
+    private readonly _sourceElement;
+    private readonly _sourceInput;
+    constructor(attributes: WritableCalcViewModel<Mapping>, skippedNodes: any);
+    get targetElement(): Element | null;
+    set targetElement(value: Element | null);
+    get sourceElement(): Element | null;
+    set sourceElement(value: Element | null);
+    get sourceInput(): Input | null;
+    set sourceInput(value: Input | null);
+}
+export declare class Input extends AbstractModelClass<Input> {
+    alias: string;
+    repositoryInputNodeId: string;
+    selectAll: boolean;
+    outputName?: OutputType;
+    readonly mappings: ModelCollection<Mapping>;
+    private _source;
+    constructor(attributes: WritableCalcViewModel<Input>, skippedNodes: any);
+    getSource(): ViewNode | Entity | null;
+    setSource(source: ViewNode | Entity): ViewNode | Entity;
+    createMapping(attributes: WritableCalcViewModel<Mapping>, skippedNodes: any): Mapping;
+}
+export declare class Element extends AbstractModelClass<Element> {
+    protected readonly $$keyAttributeName = "name";
+    name: string;
+    measureType?: MeasureType;
+    keep?: boolean;
+    transparentFilter?: boolean;
+    isProxy: boolean;
+    generatedColumn: boolean;
+    inlineType?: SimpleType;
+    calculationDefinition?: any;
+    readonly restrictions: ModelCollection<ElementRefFilter>;
+    private readonly _restrictionExpression;
+    constructor(attributes: WritableCalcViewModel<Element>, skippedNodes?: any);
+    get restrictionExpression(): Expression | null;
+    set restrictionExpression(value: Expression | null);
+    createOrMergeSimpleType(attributes: WritableCalcViewModel<SimpleType>, skippedNodes?: any): SimpleType;
+    getMapping(): Mapping | undefined;
+    createDefaultMapping(attributes: WritableCalcViewModel<Mapping>, skippedNodes: any): Mapping | null;
+    createCalculationDefinition(attributes: WritableCalcViewModel<Expression>): any;
+    createRestriction(attributes: WritableCalcViewModel<ElementRefFilter>, skippedNodes: any): ElementRefFilter;
+    createRestrictionExpression(attributes: WritableCalcViewModel<Expression>): Expression;
+    isCalculatedColumn(): boolean;
+    isRestrictedColumn(): boolean;
+    isHierarchyGererated(): true | undefined;
+}
+export declare class SimpleType extends AbstractModelClass<SimpleType> {
+    primitiveType: PrimitiveType;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    semanticType?: SemanticType;
+    isDerived?: boolean;
+    presentationScale?: number;
+    readonly valueRanges: ModelCollection<ValueRange>;
+    constructor(attributes: WritableCalcViewModel<SimpleType>, skippedNodes: any);
+}
+export declare class ValueRange extends AbstractModelClass<ValueRange> {
+    protected readonly $$keyAttributeName = "value";
+    value: string;
+    label?: string;
+    constructor(attributes: WritableCalcViewModel<ValueRange>, skippedNodes: any);
+}
+/**
+ * @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
+ */
+export declare class ElementRefFilter extends AbstractModelClass<ElementRefFilter> {
+    type: string;
+    readonly valueFilters: ModelCollection<ValueFilter>;
+    private readonly _element;
+    get element(): Element;
+    set element(value: Element);
+    createValueFilter(attributes: WritableCalcViewModel<ValueFilter>, skippedNodes: any): ValueFilter;
+}
+export {};

package/src/plugins/cap/readers/calculation-view/model/modelbase.d.ts

@@ -0,0 +1,105 @@
+export declare class ModelException extends Error {
+    objects: any;
+    constructor(message: string, objects?: any);
+}
+export declare class ObjectAlreadyExistsException extends ModelException {
+    name: string;
+    constructor(object: any, key: string, containingFeature: any);
+}
+export declare class TransformationException extends ModelException {
+    name: string;
+    constructor(message: string, objects: any[]);
+}
+export declare class UnsupportedOperationException extends ModelException {
+    name: string;
+    constructor(feature: any);
+}
+export declare class AttributeMissingException extends ModelException {
+    name: string;
+    constructor(object: any, attributeName: string);
+}
+declare class ModelFeature {
+    _owner: AbstractModel | AbstractModelClass<any> | null;
+    _name: string;
+    _isContainment: boolean;
+    constructor(_owner: AbstractModel | AbstractModelClass<any> | null, _name: string, _isContainment: boolean);
+    isContainment(): boolean;
+    getOwner(): AbstractModel | AbstractModelClass<any>;
+}
+export declare class SingleValueContainer<T extends AbstractModelClass<T>> extends ModelFeature {
+    _value: T | null;
+    constructor(owner: AbstractModel | AbstractModelClass<any> | null, name: string, isContainment: boolean);
+    set(value: T): void;
+    get(): T | null;
+}
+export declare class ModelCollection<T extends AbstractModelClass<T>> extends ModelFeature {
+    _keys: (string | undefined)[];
+    _values: {
+        [key: string]: T;
+    };
+    constructor(owner: AbstractModel | AbstractModelClass<any>, name: string, isContainment: boolean);
+    foreach(func: (value: T, key?: string, context?: any) => void): void;
+    setAt(index: number, value: T): void;
+    getAt(index: number): T | undefined;
+    addValue(value: T): T;
+    addValueNextKey(value: T, nextKey: string): T;
+    add(key: string, value: T): void;
+    addKeyValueNextKey(key: string, value: T, nextKey: string): void;
+    private _addBefore;
+    private addByIndex;
+    indexOf(key: string): number;
+    get(key: string): T;
+    _remove(key: string, noSplice: boolean): void;
+    remove(key: string, noSplice: boolean, deep?: boolean): T;
+    count(): number;
+    getUniqueKeyNumber(): string;
+    getUniqueKey(elementName: string, suffix?: string): string;
+}
+export declare abstract class AbstractModel {
+    $$isLoading: boolean;
+    constructor(isLoading?: any);
+    $getModel(): AbstractModel;
+}
+declare type IfEquals<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+declare type NonReadonlyKeys<T> = {
+    [K in keyof T]: IfEquals<{
+        -readonly [P in K]: T[P];
+    }, {
+        [P in K]: T[P];
+    }> extends true ? K : never;
+}[keyof T];
+declare type NonFunctionKeys<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export declare type WritableCalcViewModel<T> = Partial<Pick<T, NonReadonlyKeys<T> & NonFunctionKeys<T>>>;
+export declare abstract class AbstractModelClass<T extends AbstractModelClass<T>> {
+    private $$containingFeature;
+    private $$model;
+    private $$removed;
+    private $$usingFeatures;
+    private $$usingFeatureKeys;
+    private $$defaultKeyValue;
+    private $$skippedNodes;
+    protected $$keyAttributeName?: string;
+    constructor(attributes: WritableCalcViewModel<T>, skippedNodes?: any);
+    $addSkippedNodes(skippedNodes: any): void;
+    $setAttributes(changedAttributes: any, skippedNodes?: any): void;
+    $getModel(): AbstractModel | null;
+    $setModel(model: AbstractModel | null): void;
+    $getContainer(): AbstractModel | AbstractModelClass<any> | null;
+    $$setContainingFeature(feature: SingleValueContainer<any> | ModelCollection<any> | null): void;
+    $getKeyAttributeName(): string | undefined;
+    $getKeyAttributeValue(): string;
+    $hasKeyAttribute(): boolean;
+    $rename(newKey: string | number, doNotRenameContainment?: boolean): void;
+}
+declare const _default: {
+    ModelCollection: typeof ModelCollection;
+    AbstractModel: typeof AbstractModel;
+    AbstractModelClass: typeof AbstractModelClass;
+    ModelException: typeof ModelException;
+    AttributeMissingException: typeof AttributeMissingException;
+    UnsupportedOperationException: typeof UnsupportedOperationException;
+    TransformationException: typeof TransformationException;
+};
+export default _default;

package/src/plugins/cap/readers/calculation-view/model/sharedmodel.d.ts

@@ -0,0 +1,33 @@
+import XmlReader from './XmlReader';
+import { AbstractModelClass, WritableCalcViewModel } from './modelbase';
+export declare class ValueFilter extends AbstractModelClass<ValueFilter> {
+    operator: ValueFilterOperator;
+    constructor(attributes: WritableCalcViewModel<ValueFilter>, skippedNodes: any);
+}
+declare enum ValueFilterOperator {
+    EQUAL = "EQ",
+    LESS_THAN = "LT",
+    LESS_EQUAL = "LE",
+    GREATER_THAN = "GT",
+    GREATER_EQUAL = "GE",
+    BETWEEN = "BT",
+    IN = "IN",
+    CONTAINS_PATTERN = "CP",
+    IS_NULL = "NL",
+    IS_NOT_NULL = "NU"
+}
+declare const _default: {
+    NameSpace: {
+        CALCULATION: string;
+        ACCESSCONTROL: string;
+        PRIVILEGE: string;
+        VARIABLE: string;
+        DATAFOUNDATION: string;
+        DIMENSION: string;
+        GRAPH: string;
+    };
+    ValueFilter: typeof ValueFilter;
+    parseDescriptions: (reader: XmlReader, attributes: any) => any;
+    parseValueFilter: (reader: XmlReader) => ValueFilter;
+};
+export default _default;

package/src/plugins/cap/readers/calculation-view/viewmodel/CalculationViewXmlParser.d.ts

@@ -0,0 +1,62 @@
+import { ColumnView, Element, Entity, EntityType, Input, ViewModel, ViewNode, ViewNodeType } from '../model/model';
+import XmlReader from '../model/XmlReader';
+export default abstract class CalculationViewXmlParser {
+    static propagateDataTypeToDefaultNode(columnView: ColumnView): void;
+    private static _propagateDataTypeToViewNode;
+    private static _getInlineTypeFromSource;
+    static parseScenario(xml: string, model: ViewModel, fixMixedLineEndings: boolean, forceLineEndings: boolean): void;
+    private static _getDefaultNodeElementInstanceByElementName;
+    private static _createDefaultNodeElementInstanceByElementName;
+    private static _setSkippedNodes;
+    private static _checkProxyElementsInDefaultNode;
+    private static parseOrigin;
+    private static processInternalExternalConversion;
+    private static parseMaskingExpression;
+    private static parseVariable;
+    private static parseDataSource;
+    private static processTypedObjectExternalTypeOfElement;
+    private static processTypedObjectExternalTypeOfElementParameterMapping;
+    private static parseCalculationView;
+    private static parseViewAttribute;
+    private static parseRestrictedViewAttribute;
+    private static parseRankingFilter;
+    private static parseCalculatedViewAttribute;
+    private static parseInput;
+    static parseMapping(reader: XmlReader, input: Input, columnView: ColumnView, isSimpleMapping: boolean, mappingElementName?: string): boolean;
+    private static parseVariableMappings;
+    static parseVariableMapping(reader: XmlReader, variableMappingTagName?: string, columnView?: ColumnView): any;
+    private static postProcessVariableMappings;
+    static parseLogicalModel(reader: XmlReader, columnView: ColumnView, outputViewType: ViewNodeType, outputViewName: string, dataSources: {
+        [key: string]: {
+            id?: string;
+            type?: string;
+        };
+    }, isStarJoin: boolean): void;
+    private static parseStarJoinPrivateJoinColumns;
+    private static parseStarJoinSharedJoinColumns;
+    private static parseStarJoinJoinProperties;
+    private static processTemporalJoinProperties;
+    private static processStarJoinAliasedSharedJoinColumns;
+    private static parseAssociatedHierarchyFeature;
+    private static processStarJoinSemanticAttributeMappings;
+    private static remove$localFromStarJoinPrivateJoinColumns;
+    private static getStarJoinViewNodeInput;
+    private static getStarJoinViewNodeInputSource;
+    private static parseCurrencyAndUnitConversion;
+    static createDefaultNodeElement(viewNode: ViewNode, attributes: any, isScriptNode: boolean, isStarJoin: boolean): void;
+    private static parseUnitCurrencyAttribute;
+    static parseAttribute(reader: XmlReader, viewNode: ViewNode, allAttributes: Element[]): boolean;
+    static parseCalculatedAttribute(reader: XmlReader, viewNode: ViewNode, allAttributes: Element[]): boolean;
+    static parseMeasure(reader: XmlReader, viewNode: ViewNode, allAttributes: Element[]): any;
+    static parseCalculatedMeasure(reader: XmlReader, viewNode: ViewNode, allAttributes: Element[]): any;
+    static parseRestrictedMeasure(reader: XmlReader, viewNode: ViewNode, allAttributes: Element[]): any;
+    private static parseExceptionAggregationMetadata;
+    private static doLoadPostProcessing;
+    private static registerForLoadPostProcessing;
+    private static excecuteLoadPostProcessingCallBackQueue;
+}
+export declare const getElementFromColumnView: (columnView: ColumnView, name: string) => Element | null;
+export declare const getEntity: (columnView: ColumnView, id: string, entityType?: EntityType | undefined) => Entity;
+export declare const getElementFromsharedEntity: (entity: Entity, elementName: string) => Element;
+export declare const getParameterFromColumnView: (columnView: ColumnView, name: string) => import("../model/model").Parameter | null;
+export declare const processUDFParameter: (columnView: ColumnView, udfParameter: any, values: any) => any;

package/src/plugins/cap/readers/calculation-view/viewmodel/CalculationViewXmlParserHelper.d.ts

@@ -0,0 +1,14 @@
+import XmlReader from '../model/XmlReader';
+import { ColumnView, ViewNode } from '../model/model';
+export default abstract class CalculationViewXmlParserHelper {
+    static populateSimpleTypeAttributesFromElementAttributes(elementAttributes: any, simpleTypeAttributes: any): void;
+    static mapViewNodeType(type: any): any;
+    static createEndUserTextsIfRequired(object: any, attributes: any): void;
+    static getBooleanFromString(input: any): any;
+    static populateJoinAttributesFromViewNodeAttributes(joinAttributes: any, viewNodeAttributes: any): void;
+    static mapRepositoryTypeToEntityType(type: any): any;
+    static isItDesigntimeRepositoryObject(type: any): boolean;
+    static processWindowFunction(reader: XmlReader, columnView: ColumnView, viewNode: ViewNode): void;
+    static checkForStarJoinWithDomAPI(reader: XmlReader): boolean;
+    static parseUDFParameter(reader: XmlReader, parentTagName: string): any;
+}

package/src/project-api/ProjectImpl.d.ts

@@ -78,4 +78,6 @@ export default class ProjectImpl implements ProjectApi {
     getDataInfo(data: any, mainEntityName?: string, logger?: IChildLogger): Promise<any>;
     private modifyCDSProfile;
     private modifyCDSProductionDB;
+    private modifyLowcodeEventHandler;
+    private modifyPackgeJSON;
 }