tm1npm 1.0.0

package/lib/objects/ChoreTask.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChoreTask = void 0;
+const TM1Object_1 = require("./TM1Object");
+const Utils_1 = require("../utils/Utils");
+class ChoreTask extends TM1Object_1.TM1Object {
+    constructor(step, processName, parameters) {
+        /**
+         * :param step: step in the execution order of the Chores' processes. 1 to n, where n the number of processes
+         * :param process_name: name of the process
+         * :param parameters: list of dictionaries with 'Name' and 'Value' property:
+         *                     [{
+         *                         'Name': '..',
+         *                         'Value': '..'
+         *                     },
+         *                     ...
+         *                     ]
+         */
+        super();
+        this._step = step;
+        this._processName = processName;
+        this._parameters = parameters;
+    }
+    static fromDict(choreTaskAsDict, step) {
+        let processName;
+        if ('Process' in choreTaskAsDict) {
+            processName = choreTaskAsDict['Process']['Name'];
+        }
+        else {
+            // Extract "ProcessName" from "Processes('ProcessName')"
+            processName = choreTaskAsDict['Process@odata.bind'].slice(11, -2);
+        }
+        return new ChoreTask(step !== undefined ? step : parseInt(choreTaskAsDict['Step']), processName, (choreTaskAsDict['Parameters'] || []).map((p) => ({
+            Name: p['Name'],
+            Value: p['Value']
+        })));
+    }
+    get bodyAsDict() {
+        const bodyAsDict = {};
+        bodyAsDict['Process@odata.bind'] = (0, Utils_1.formatUrl)("Processes('{}')", this._processName);
+        bodyAsDict['Parameters'] = this._parameters;
+        return bodyAsDict;
+    }
+    get step() {
+        return this._step;
+    }
+    get processName() {
+        return this._processName;
+    }
+    get parameters() {
+        return this._parameters;
+    }
+    get body() {
+        return JSON.stringify(this.bodyAsDict);
+    }
+    equals(other) {
+        return this.processName === other.processName &&
+            JSON.stringify(this.parameters) === JSON.stringify(other.parameters);
+    }
+    notEquals(other) {
+        return this.processName !== other.processName ||
+            JSON.stringify(this._parameters) !== JSON.stringify(other.parameters);
+    }
+}
+exports.ChoreTask = ChoreTask;
+//# sourceMappingURL=ChoreTask.js.map

package/lib/objects/Cube.d.ts

@@ -0,0 +1,26 @@
+import { TM1Object } from './TM1Object';
+import { Rules } from './Rules';
+export declare class Cube extends TM1Object {
+    /** Abstraction of a TM1 Cube
+     *
+     */
+    private _name;
+    private _dimensions;
+    private _rules?;
+    constructor(name: string, dimensions: Iterable<string>, rules?: string | Rules);
+    get name(): string;
+    get dimensions(): string[];
+    set dimensions(value: string[]);
+    get hasRules(): boolean;
+    get rules(): Rules | undefined;
+    set rules(value: string | Rules | undefined);
+    get skipcheck(): boolean;
+    get undefvals(): boolean;
+    get feedstrings(): boolean;
+    static fromJSON(cubeAsJson: string): Cube;
+    static fromDict(cubeAsDict: any): Cube;
+    get body(): string;
+    get bodyAsDict(): any;
+    private constructBody;
+}
+//# sourceMappingURL=Cube.d.ts.map

package/lib/objects/Cube.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cube.d.ts","sourceRoot":"","sources":["../../src/objects/Cube.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,IAAK,SAAQ,SAAS;IAC/B;;OAEG;IAEH,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,MAAM,CAAC,CAAQ;gBAEX,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK;IAa9E,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,UAAU,IAAI,MAAM,EAAE,CAEhC;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,EAEpC;IAED,IAAW,QAAQ,IAAI,OAAO,CAK7B;IAED,IAAW,KAAK,IAAI,KAAK,GAAG,SAAS,CAEpC;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,EAUjD;IAED,IAAW,SAAS,IAAI,OAAO,CAK9B;IAED,IAAW,SAAS,IAAI,OAAO,CAK9B;IAED,IAAW,WAAW,IAAI,OAAO,CAKhC;WAEa,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;WAUlC,QAAQ,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI;IAa7C,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,UAAU,IAAI,GAAG,CAE3B;IAED,OAAO,CAAC,aAAa;CAYxB"}

package/lib/objects/Cube.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cube = void 0;
+const TM1Object_1 = require("./TM1Object");
+const Rules_1 = require("./Rules");
+class Cube extends TM1Object_1.TM1Object {
+    constructor(name, dimensions, rules) {
+        /**
+         *
+         * :param name: name of the Cube
+         * :param dimensions: list of (existing) dimension names
+         * :param rules: instance of .Objects.Rules
+         */
+        super();
+        /** Abstraction of a TM1 Cube
+         *
+         */
+        this._name = '';
+        this._dimensions = [];
+        this._name = name;
+        this.dimensions = Array.from(dimensions);
+        this.rules = rules;
+    }
+    get name() {
+        return this._name;
+    }
+    get dimensions() {
+        return this._dimensions;
+    }
+    set dimensions(value) {
+        this._dimensions = value;
+    }
+    get hasRules() {
+        if (this._rules) {
+            return true;
+        }
+        return false;
+    }
+    get rules() {
+        return this._rules;
+    }
+    set rules(value) {
+        if (value === undefined || value === null) {
+            this._rules = undefined;
+        }
+        else if (typeof value === 'string') {
+            this._rules = new Rules_1.Rules(value);
+        }
+        else if (value instanceof Rules_1.Rules) {
+            this._rules = value;
+        }
+        else {
+            throw new Error('value must be undefined or of type string or Rules');
+        }
+    }
+    get skipcheck() {
+        if (this.hasRules && this.rules) {
+            return this.rules.skipcheck;
+        }
+        return false;
+    }
+    get undefvals() {
+        if (this.hasRules && this.rules) {
+            return this.rules.undefvals;
+        }
+        return false;
+    }
+    get feedstrings() {
+        if (this.hasRules && this.rules) {
+            return this.rules.feedstrings;
+        }
+        return false;
+    }
+    static fromJSON(cubeAsJson) {
+        /** Alternative constructor
+         *
+         * :param cube_as_json: user as JSON string
+         * :return: cube, an instance of this class
+         */
+        const cubeAsDict = JSON.parse(cubeAsJson);
+        return Cube.fromDict(cubeAsDict);
+    }
+    static fromDict(cubeAsDict) {
+        /** Alternative constructor
+         *
+         * :param cube_as_dict: user as dict
+         * :return: user, an instance of this class
+         */
+        return new Cube(cubeAsDict.Name, cubeAsDict.Dimensions.map((dimension) => dimension.Name), cubeAsDict.Rules ? new Rules_1.Rules(cubeAsDict.Rules) : undefined);
+    }
+    get body() {
+        return JSON.stringify(this.constructBody());
+    }
+    get bodyAsDict() {
+        return this.constructBody();
+    }
+    constructBody() {
+        const body = {
+            Name: this._name,
+            Dimensions: this._dimensions.map(dim => ({ Name: dim }))
+        };
+        if (this._rules) {
+            body.Rules = this._rules.text;
+        }
+        return body;
+    }
+}
+exports.Cube = Cube;
+//# sourceMappingURL=Cube.js.map

package/lib/objects/Dimension.d.ts

@@ -0,0 +1,26 @@
+import { TM1Object } from './TM1Object';
+import { Hierarchy } from './Hierarchy';
+export declare class Dimension extends TM1Object {
+    private _name;
+    private _hierarchies;
+    private _attributes;
+    constructor(name: string, hierarchies?: Hierarchy[]);
+    static fromJSON(dimensionAsJson: string): Dimension;
+    static fromDict(dimensionAsDict: any): Dimension;
+    get name(): string;
+    set name(value: string);
+    get uniqueName(): string;
+    get hierarchies(): Hierarchy[];
+    get hierarchyNames(): string[];
+    get defaultHierarchy(): Hierarchy | undefined;
+    get body(): string;
+    get bodyAsDict(): any;
+    private constructBody;
+    addHierarchy(hierarchy: Hierarchy): void;
+    removeHierarchy(hierarchyName: string): boolean;
+    getHierarchy(hierarchyName: string): Hierarchy | undefined;
+    hasHierarchy(hierarchyName: string): boolean;
+    [Symbol.iterator](): Iterator<Hierarchy>;
+    get length(): number;
+}
+//# sourceMappingURL=Dimension.d.ts.map

package/lib/objects/Dimension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dimension.d.ts","sourceRoot":"","sources":["../../src/objects/Dimension.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,qBAAa,SAAU,SAAQ,SAAS;IACpC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,WAAW,CAA2B;gBAElC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,SAAS,EAAE;WAOrC,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS;WAK5C,QAAQ,CAAC,eAAe,EAAE,GAAG,GAAG,SAAS;IAQvD,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,CAAC,KAAK,EAAE,MAAM,EAQ5B;IAED,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED,IAAW,WAAW,IAAI,SAAS,EAAE,CAEpC;IAED,IAAW,cAAc,IAAI,MAAM,EAAE,CAEpC;IAED,IAAW,gBAAgB,IAAI,SAAS,GAAG,SAAS,CAEnD;IAED,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,UAAU,IAAI,GAAG,CAE3B;IAED,OAAO,CAAC,aAAa;IAOd,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAKxC,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO;IAW/C,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAK1D,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO;IAK3C,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,SAAS,CAAC;IAIhD,IAAW,MAAM,IAAI,MAAM,CAE1B;CACJ"}

package/lib/objects/Dimension.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dimension = void 0;
+const TM1Object_1 = require("./TM1Object");
+const Hierarchy_1 = require("./Hierarchy");
+class Dimension extends TM1Object_1.TM1Object {
+    constructor(name, hierarchies) {
+        super();
+        this._hierarchies = [];
+        this._attributes = {};
+        this._name = name;
+        this._hierarchies = hierarchies ? [...hierarchies] : [];
+        this._attributes = { Caption: name };
+    }
+    static fromJSON(dimensionAsJson) {
+        const dimensionAsDict = JSON.parse(dimensionAsJson);
+        return Dimension.fromDict(dimensionAsDict);
+    }
+    static fromDict(dimensionAsDict) {
+        const hierarchies = dimensionAsDict.Hierarchies ?
+            dimensionAsDict.Hierarchies.map((h) => Hierarchy_1.Hierarchy.fromDict(h, dimensionAsDict.Name)) : [];
+        return new Dimension(dimensionAsDict.Name, hierarchies);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        for (const hierarchy of this._hierarchies) {
+            hierarchy.dimensionName = value;
+            if (hierarchy.name === this._name) {
+                hierarchy.name = value;
+            }
+        }
+        this._name = value;
+    }
+    get uniqueName() {
+        return '[' + this._name + ']';
+    }
+    get hierarchies() {
+        return this._hierarchies;
+    }
+    get hierarchyNames() {
+        return this._hierarchies.map(h => h.name);
+    }
+    get defaultHierarchy() {
+        return this._hierarchies[0];
+    }
+    get body() {
+        return JSON.stringify(this.constructBody());
+    }
+    get bodyAsDict() {
+        return this.constructBody();
+    }
+    constructBody() {
+        return {
+            Name: this._name,
+            Hierarchies: this._hierarchies.map(h => h.bodyAsDict)
+        };
+    }
+    addHierarchy(hierarchy) {
+        hierarchy.dimensionName = this._name;
+        this._hierarchies.push(hierarchy);
+    }
+    removeHierarchy(hierarchyName) {
+        const index = this._hierarchies.findIndex(h => h.name.toLowerCase() === hierarchyName.toLowerCase());
+        if (index !== -1) {
+            this._hierarchies.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    getHierarchy(hierarchyName) {
+        return this._hierarchies.find(h => h.name.toLowerCase() === hierarchyName.toLowerCase());
+    }
+    hasHierarchy(hierarchyName) {
+        return this._hierarchies.some(h => h.name.toLowerCase() === hierarchyName.toLowerCase());
+    }
+    *[Symbol.iterator]() {
+        yield* this._hierarchies;
+    }
+    get length() {
+        return this._hierarchies.length;
+    }
+}
+exports.Dimension = Dimension;
+//# sourceMappingURL=Dimension.js.map

package/lib/objects/Element.d.ts

@@ -0,0 +1,35 @@
+import { TM1Object } from './TM1Object';
+export declare enum ElementType {
+    NUMERIC = 1,
+    STRING = 2,
+    CONSOLIDATED = 3
+}
+export declare class Element extends TM1Object {
+    static readonly ELEMENT_ATTRIBUTES_PREFIX = "}ElementAttributes_";
+    private _name;
+    private _uniqueName?;
+    private _index?;
+    private _elementType;
+    private _attributes?;
+    constructor(name: string, elementType: ElementType | string, attributes?: string[], uniqueName?: string, index?: number);
+    private parseElementType;
+    static fromDict(elementAsDict: any): Element;
+    get name(): string;
+    set name(value: string);
+    get uniqueName(): string | undefined;
+    set uniqueName(value: string | undefined);
+    get index(): number | undefined;
+    set index(value: number | undefined);
+    get elementType(): ElementType;
+    set elementType(value: ElementType | string);
+    get attributes(): string[] | undefined;
+    set attributes(value: string[] | undefined);
+    get body(): string;
+    get bodyAsDict(): any;
+    private constructBody;
+    private elementTypeToString;
+    isNumeric(): boolean;
+    isString(): boolean;
+    isConsolidated(): boolean;
+}
+//# sourceMappingURL=Element.d.ts.map

package/lib/objects/Element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Element.d.ts","sourceRoot":"","sources":["../../src/objects/Element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,oBAAY,WAAW;IACnB,OAAO,IAAI;IACX,MAAM,IAAI;IACV,YAAY,IAAI;CACnB;AAED,qBAAa,OAAQ,SAAQ,SAAS;IAClC,gBAAuB,yBAAyB,yBAAyB;IAEzE,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,WAAW,CAAC,CAAW;gBAG3B,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,WAAW,GAAG,MAAM,EACjC,UAAU,CAAC,EAAE,MAAM,EAAE,EACrB,UAAU,CAAC,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,MAAM;IAUlB,OAAO,CAAC,gBAAgB;WAiBV,QAAQ,CAAC,aAAa,EAAE,GAAG,GAAG,OAAO;IAUnD,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,CAAC,KAAK,EAAE,MAAM,EAE5B;IAED,IAAW,UAAU,IAAI,MAAM,GAAG,SAAS,CAE1C;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAE9C;IAED,IAAW,KAAK,IAAI,MAAM,GAAG,SAAS,CAErC;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAEzC;IAED,IAAW,WAAW,IAAI,WAAW,CAEpC;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,EAEjD;IAED,IAAW,UAAU,IAAI,MAAM,EAAE,GAAG,SAAS,CAE5C;IAED,IAAW,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,EAEhD;IAED,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,UAAU,IAAI,GAAG,CAE3B;IAED,OAAO,CAAC,aAAa;IAqBrB,OAAO,CAAC,mBAAmB;IAapB,SAAS,IAAI,OAAO;IAIpB,QAAQ,IAAI,OAAO;IAInB,cAAc,IAAI,OAAO;CAGnC"}

package/lib/objects/Element.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Element = exports.ElementType = void 0;
+const TM1Object_1 = require("./TM1Object");
+var ElementType;
+(function (ElementType) {
+    ElementType[ElementType["NUMERIC"] = 1] = "NUMERIC";
+    ElementType[ElementType["STRING"] = 2] = "STRING";
+    ElementType[ElementType["CONSOLIDATED"] = 3] = "CONSOLIDATED";
+})(ElementType || (exports.ElementType = ElementType = {}));
+class Element extends TM1Object_1.TM1Object {
+    constructor(name, elementType, attributes, uniqueName, index) {
+        super();
+        this._name = name;
+        this._uniqueName = uniqueName;
+        this._index = index;
+        this._elementType = this.parseElementType(elementType);
+        this._attributes = attributes;
+    }
+    parseElementType(elementType) {
+        if (typeof elementType === 'string') {
+            const lowerType = elementType.toLowerCase().replace(/\s+/g, '');
+            switch (lowerType) {
+                case 'numeric':
+                    return ElementType.NUMERIC;
+                case 'string':
+                    return ElementType.STRING;
+                case 'consolidated':
+                    return ElementType.CONSOLIDATED;
+                default:
+                    throw new Error(`Invalid element type: '${elementType}'`);
+            }
+        }
+        return elementType;
+    }
+    static fromDict(elementAsDict) {
+        return new Element(elementAsDict.Name, elementAsDict.Type, elementAsDict.Attributes, elementAsDict.UniqueName, elementAsDict.Index);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get uniqueName() {
+        return this._uniqueName;
+    }
+    set uniqueName(value) {
+        this._uniqueName = value;
+    }
+    get index() {
+        return this._index;
+    }
+    set index(value) {
+        this._index = value;
+    }
+    get elementType() {
+        return this._elementType;
+    }
+    set elementType(value) {
+        this._elementType = this.parseElementType(value);
+    }
+    get attributes() {
+        return this._attributes;
+    }
+    set attributes(value) {
+        this._attributes = value;
+    }
+    get body() {
+        return JSON.stringify(this.constructBody());
+    }
+    get bodyAsDict() {
+        return this.constructBody();
+    }
+    constructBody() {
+        const body = {
+            Name: this._name,
+            Type: this.elementTypeToString(this._elementType)
+        };
+        if (this._uniqueName !== undefined) {
+            body.UniqueName = this._uniqueName;
+        }
+        if (this._index !== undefined) {
+            body.Index = this._index;
+        }
+        if (this._attributes !== undefined) {
+            body.Attributes = this._attributes;
+        }
+        return body;
+    }
+    elementTypeToString(elementType) {
+        switch (elementType) {
+            case ElementType.NUMERIC:
+                return 'Numeric';
+            case ElementType.STRING:
+                return 'String';
+            case ElementType.CONSOLIDATED:
+                return 'Consolidated';
+            default:
+                return 'String';
+        }
+    }
+    isNumeric() {
+        return this._elementType === ElementType.NUMERIC;
+    }
+    isString() {
+        return this._elementType === ElementType.STRING;
+    }
+    isConsolidated() {
+        return this._elementType === ElementType.CONSOLIDATED;
+    }
+}
+exports.Element = Element;
+Element.ELEMENT_ATTRIBUTES_PREFIX = "}ElementAttributes_";
+//# sourceMappingURL=Element.js.map

package/lib/objects/ElementAttribute.d.ts

@@ -0,0 +1,28 @@
+import { TM1Object } from './TM1Object';
+export declare enum ElementAttributeType {
+    NUMERIC = 1,
+    STRING = 2,
+    ALIAS = 3
+}
+export declare class ElementAttribute extends TM1Object {
+    private _name;
+    private _attributeType;
+    constructor(name: string, attributeType: ElementAttributeType | string);
+    private parseAttributeType;
+    static fromJSON(elementAttributeAsJson: string): ElementAttribute;
+    static fromDict(elementAttributeAsDict: any): ElementAttribute;
+    get name(): string;
+    set name(value: string);
+    get attributeType(): string;
+    set attributeType(value: ElementAttributeType | string);
+    get attributeTypeEnum(): ElementAttributeType;
+    get body(): string;
+    get bodyAsDict(): any;
+    private attributeTypeToString;
+    isNumeric(): boolean;
+    isString(): boolean;
+    isAlias(): boolean;
+    equals(other: TM1Object): boolean;
+    equalsString(other: string): boolean;
+}
+//# sourceMappingURL=ElementAttribute.d.ts.map

package/lib/objects/ElementAttribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementAttribute.d.ts","sourceRoot":"","sources":["../../src/objects/ElementAttribute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,oBAAY,oBAAoB;IAC5B,OAAO,IAAI;IACX,MAAM,IAAI;IACV,KAAK,IAAI;CACZ;AAED,qBAAa,gBAAiB,SAAQ,SAAS;IAC3C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,cAAc,CAAuB;gBAEjC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,oBAAoB,GAAG,MAAM;IAMtE,OAAO,CAAC,kBAAkB;WAiBZ,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,gBAAgB;WAI1D,QAAQ,CAAC,sBAAsB,EAAE,GAAG,GAAG,gBAAgB;IAOrE,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,CAAC,KAAK,EAAE,MAAM,EAE5B;IAED,IAAW,aAAa,IAAI,MAAM,CAEjC;IAED,IAAW,aAAa,CAAC,KAAK,EAAE,oBAAoB,GAAG,MAAM,EAE5D;IAED,IAAW,iBAAiB,IAAI,oBAAoB,CAEnD;IAED,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,UAAU,IAAI,GAAG,CAK3B;IAED,OAAO,CAAC,qBAAqB;IAatB,SAAS,IAAI,OAAO;IAIpB,QAAQ,IAAI,OAAO;IAInB,OAAO,IAAI,OAAO;IAIlB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAQjC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAI9C"}

package/lib/objects/ElementAttribute.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementAttribute = exports.ElementAttributeType = void 0;
+const TM1Object_1 = require("./TM1Object");
+var ElementAttributeType;
+(function (ElementAttributeType) {
+    ElementAttributeType[ElementAttributeType["NUMERIC"] = 1] = "NUMERIC";
+    ElementAttributeType[ElementAttributeType["STRING"] = 2] = "STRING";
+    ElementAttributeType[ElementAttributeType["ALIAS"] = 3] = "ALIAS";
+})(ElementAttributeType || (exports.ElementAttributeType = ElementAttributeType = {}));
+class ElementAttribute extends TM1Object_1.TM1Object {
+    constructor(name, attributeType) {
+        super();
+        this._name = name;
+        this._attributeType = this.parseAttributeType(attributeType);
+    }
+    parseAttributeType(attributeType) {
+        if (typeof attributeType === 'string') {
+            const lowerType = attributeType.toLowerCase().replace(/\s+/g, '');
+            switch (lowerType) {
+                case 'numeric':
+                    return ElementAttributeType.NUMERIC;
+                case 'string':
+                    return ElementAttributeType.STRING;
+                case 'alias':
+                    return ElementAttributeType.ALIAS;
+                default:
+                    throw new Error(`Invalid attribute type: '${attributeType}'`);
+            }
+        }
+        return attributeType;
+    }
+    static fromJSON(elementAttributeAsJson) {
+        return ElementAttribute.fromDict(JSON.parse(elementAttributeAsJson));
+    }
+    static fromDict(elementAttributeAsDict) {
+        return new ElementAttribute(elementAttributeAsDict.Name, elementAttributeAsDict.Type);
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get attributeType() {
+        return this.attributeTypeToString(this._attributeType);
+    }
+    set attributeType(value) {
+        this._attributeType = this.parseAttributeType(value);
+    }
+    get attributeTypeEnum() {
+        return this._attributeType;
+    }
+    get body() {
+        return JSON.stringify(this.bodyAsDict);
+    }
+    get bodyAsDict() {
+        return {
+            Name: this._name,
+            Type: this.attributeType
+        };
+    }
+    attributeTypeToString(attributeType) {
+        switch (attributeType) {
+            case ElementAttributeType.NUMERIC:
+                return 'Numeric';
+            case ElementAttributeType.STRING:
+                return 'String';
+            case ElementAttributeType.ALIAS:
+                return 'Alias';
+            default:
+                return 'String';
+        }
+    }
+    isNumeric() {
+        return this._attributeType === ElementAttributeType.NUMERIC;
+    }
+    isString() {
+        return this._attributeType === ElementAttributeType.STRING;
+    }
+    isAlias() {
+        return this._attributeType === ElementAttributeType.ALIAS;
+    }
+    equals(other) {
+        if (other instanceof ElementAttribute) {
+            return this._name.toLowerCase().replace(/\s+/g, '') ===
+                other._name.toLowerCase().replace(/\s+/g, '');
+        }
+        return false;
+    }
+    equalsString(other) {
+        return this._name.toLowerCase().replace(/\s+/g, '') ===
+            other.toLowerCase().replace(/\s+/g, '');
+    }
+}
+exports.ElementAttribute = ElementAttribute;
+//# sourceMappingURL=ElementAttribute.js.map

package/lib/objects/Git.d.ts

@@ -0,0 +1,21 @@
+import { GitCommit } from './GitCommit';
+import { GitRemote } from './GitRemote';
+export declare class Git {
+    /** Abstraction of Git object
+     */
+    private _url;
+    private _deployment;
+    private _force;
+    private _deployedCommit;
+    private _remote;
+    private _config?;
+    constructor(url: string, deployment: string, force: boolean, deployedCommit: GitCommit, remote: GitRemote, config?: Record<string, any>);
+    get url(): string;
+    get force(): boolean;
+    get config(): Record<string, any> | undefined;
+    get deployment(): string;
+    get deployedCommit(): GitCommit;
+    get remote(): GitRemote;
+    static fromDict(jsonResponse: any): Git;
+}
+//# sourceMappingURL=Git.d.ts.map

package/lib/objects/Git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Git.d.ts","sourceRoot":"","sources":["../../src/objects/Git.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,qBAAa,GAAG;IACZ;OACG;IAEH,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,eAAe,CAAY;IACnC,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,OAAO,CAAC,CAAsB;gBAGlC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,OAAO,EACd,cAAc,EAAE,SAAS,EACzB,MAAM,EAAE,SAAS,EACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAkBhC,IAAW,GAAG,IAAI,MAAM,CAEvB;IAED,IAAW,KAAK,IAAI,OAAO,CAE1B;IAED,IAAW,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAEnD;IAED,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED,IAAW,cAAc,IAAI,SAAS,CAErC;IAED,IAAW,MAAM,IAAI,SAAS,CAE7B;WAEa,QAAQ,CAAC,YAAY,EAAE,GAAG,GAAG,GAAG;CAuBjD"}