tm1npm 1.0.0

package/lib/objects/ProcessDebugBreakpoint.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessDebugBreakpoint = exports.BreakPointType = exports.HitMode = void 0;
+const TM1Object_1 = require("./TM1Object");
+var HitMode;
+(function (HitMode) {
+    HitMode["BREAK_ALWAYS"] = "BreakAlways";
+    HitMode["BREAK_EQUAL"] = "BreakEqual";
+    HitMode["BREAK_GREATER_OR_EQUAL"] = "BreakGreaterOrEqual";
+})(HitMode || (exports.HitMode = HitMode = {}));
+var BreakPointType;
+(function (BreakPointType) {
+    // A breakpoint that pauses execution when the named variable is written to
+    BreakPointType["PROCESS_DEBUG_CONTEXT_DATA_BREAK_POINT"] = "ProcessDebugContextDataBreakpoint";
+    // A breakpoint that pauses execution at a specific script line
+    BreakPointType["PROCESS_DEBUG_CONTEXT_LINE_BREAK_POINT"] = "ProcessDebugContextLineBreakpoint";
+    // A breakpoint that pauses execution when an object lock is acquired.
+    BreakPointType["PROCESS_DEBUG_CONTEXT_LOCK_BREAK_POINT"] = "ProcessDebugContextLockBreakpoint";
+})(BreakPointType || (exports.BreakPointType = BreakPointType = {}));
+class ProcessDebugBreakpoint extends TM1Object_1.TM1Object {
+    constructor(breakpointId, breakpointType = BreakPointType.PROCESS_DEBUG_CONTEXT_LINE_BREAK_POINT, enabled = true, hitMode = HitMode.BREAK_ALWAYS, hitCount = 0, expression = '', variableName = '', processName = '', procedure = '', lineNumber = 0, objectName = '', objectType = '', lockMode = '') {
+        super();
+        this._type = this.parseBreakPointType(breakpointType);
+        this._id = breakpointId;
+        this._enabled = enabled;
+        this._hitMode = this.parseHitMode(hitMode);
+        this._hitCount = hitCount;
+        this._expression = expression;
+        this._variableName = variableName;
+        this._processName = processName;
+        this._procedure = procedure;
+        this._lineNumber = lineNumber;
+        this._objectName = objectName;
+        this._objectType = objectType;
+        this._lockMode = lockMode;
+    }
+    parseBreakPointType(breakpointType) {
+        if (typeof breakpointType === 'string') {
+            for (const member of Object.values(BreakPointType)) {
+                if (member.toLowerCase() === breakpointType.replace(/\s+/g, '').toLowerCase()) {
+                    return member;
+                }
+            }
+            throw new Error(`Invalid BreakPointType: '${breakpointType}'`);
+        }
+        return breakpointType;
+    }
+    parseHitMode(hitMode) {
+        if (typeof hitMode === 'string') {
+            for (const member of Object.values(HitMode)) {
+                if (member.toLowerCase() === hitMode.replace(/\s+/g, '').toLowerCase()) {
+                    return member;
+                }
+            }
+            throw new Error(`Invalid HitMode: '${hitMode}'`);
+        }
+        return hitMode;
+    }
+    static fromDict(breakpointAsDict) {
+        /**
+         *
+         * :param breakpoint_as_dict
+         * :return: an instance of this class
+         */
+        const breakpointType = breakpointAsDict['@odata.type'].substring(16);
+        return new ProcessDebugBreakpoint(breakpointAsDict['ID'], breakpointType, breakpointAsDict['Enabled'], breakpointAsDict['HitMode'], breakpointAsDict['HitCount'], breakpointAsDict['Expression'], breakpointType === "ProcessDebugContextDataBreakpoint" ? breakpointAsDict['VariableName'] : "", breakpointType === "ProcessDebugContextLineBreakpoint" ? breakpointAsDict['ProcessName'] : "", breakpointType === "ProcessDebugContextLineBreakpoint" ? breakpointAsDict['Procedure'] : "", breakpointType === "ProcessDebugContextLineBreakpoint" ? breakpointAsDict['LineNumber'] : 0, breakpointType === "ProcessDebugContextLockBreakpoint" ? breakpointAsDict['ObjectName'] : "", breakpointType === "ProcessDebugContextLockBreakpoint" ? breakpointAsDict['ObjectType'] : "", breakpointType === "ProcessDebugContextLockBreakpoint" ? breakpointAsDict['LockMode'] : "");
+    }
+    get breakpointType() {
+        return this._type.toString();
+    }
+    get breakpointId() {
+        return this._id;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(value) {
+        this._enabled = value;
+    }
+    get hitMode() {
+        return this._hitMode.toString();
+    }
+    set hitMode(value) {
+        this._hitMode = this.parseHitMode(value);
+    }
+    get hitCount() {
+        return this._hitCount;
+    }
+    get expression() {
+        return this._expression;
+    }
+    set expression(value) {
+        this._expression = value;
+    }
+    get variableName() {
+        return this._variableName;
+    }
+    set variableName(value) {
+        this._variableName = value;
+    }
+    get processName() {
+        return this._processName;
+    }
+    set processName(value) {
+        this._processName = value;
+    }
+    get procedure() {
+        return this._procedure;
+    }
+    set procedure(value) {
+        this._procedure = value;
+    }
+    get lineNumber() {
+        return this._lineNumber;
+    }
+    set lineNumber(value) {
+        this._lineNumber = value;
+    }
+    get objectName() {
+        return this._objectName;
+    }
+    set objectName(value) {
+        this._objectName = value;
+    }
+    get objectType() {
+        return this._objectType;
+    }
+    set objectType(value) {
+        this._objectType = value;
+    }
+    get lockMode() {
+        return this._lockMode;
+    }
+    set lockMode(value) {
+        this._lockMode = value;
+    }
+    get body() {
+        return JSON.stringify(this.constructBody());
+    }
+    get bodyAsDict() {
+        return this.constructBody();
+    }
+    constructBody() {
+        const bodyAsDict = {
+            '@odata.type': "#ibm.tm1.api.v1." + this._type,
+            'ID': this._id,
+            'Enabled': this._enabled,
+            'HitMode': this._hitMode.toString(),
+            'Expression': this._expression
+        };
+        if (this._type === BreakPointType.PROCESS_DEBUG_CONTEXT_DATA_BREAK_POINT) {
+            bodyAsDict['VariableName'] = this._variableName;
+        }
+        else if (this._type === BreakPointType.PROCESS_DEBUG_CONTEXT_LINE_BREAK_POINT) {
+            bodyAsDict['ProcessName'] = this._processName;
+            bodyAsDict['Procedure'] = this._procedure;
+            bodyAsDict['LineNumber'] = this._lineNumber;
+        }
+        else if (this._type === BreakPointType.PROCESS_DEBUG_CONTEXT_LOCK_BREAK_POINT) {
+            bodyAsDict['ObjectName'] = this._objectName;
+            bodyAsDict['ObjectType'] = this._objectType;
+            bodyAsDict['LockMode'] = this._lockMode;
+        }
+        return bodyAsDict;
+    }
+}
+exports.ProcessDebugBreakpoint = ProcessDebugBreakpoint;
+//# sourceMappingURL=ProcessDebugBreakpoint.js.map

package/lib/objects/ProcessParameter.d.ts

@@ -0,0 +1,23 @@
+import { TM1Object } from './TM1Object';
+export declare enum ProcessParameterType {
+    String = "String",
+    Numeric = "Numeric"
+}
+export declare class ProcessParameter extends TM1Object {
+    private _name;
+    private _prompt;
+    private _value;
+    private _type;
+    constructor(name: string, prompt?: string, value?: string | number, type?: ProcessParameterType);
+    get name(): string;
+    set name(name: string);
+    get prompt(): string;
+    set prompt(prompt: string);
+    get value(): string | number;
+    set value(value: string | number);
+    get type(): ProcessParameterType;
+    set type(type: ProcessParameterType);
+    get body(): string;
+    static fromDict(parameterAsDict: any): ProcessParameter;
+}
+//# sourceMappingURL=ProcessParameter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessParameter.d.ts","sourceRoot":"","sources":["../../src/objects/ProcessParameter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,oBAAY,oBAAoB;IAC5B,MAAM,WAAW;IACjB,OAAO,YAAY;CACtB;AAED,qBAAa,gBAAiB,SAAQ,SAAS;IAC3C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,KAAK,CAAuB;gBAGhC,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,MAAW,EACnB,KAAK,GAAE,MAAM,GAAG,MAAW,EAC3B,IAAI,GAAE,oBAAkD;IAS5D,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,CAAC,IAAI,EAAE,MAAM,EAE3B;IAED,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,IAAW,MAAM,CAAC,MAAM,EAAE,MAAM,EAE/B;IAED,IAAW,KAAK,IAAI,MAAM,GAAG,MAAM,CAElC;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAEtC;IAED,IAAW,IAAI,IAAI,oBAAoB,CAEtC;IAED,IAAW,IAAI,CAAC,IAAI,EAAE,oBAAoB,EAEzC;IAED,IAAW,IAAI,IAAI,MAAM,CAOxB;WAEa,QAAQ,CAAC,eAAe,EAAE,GAAG,GAAG,gBAAgB;CAQjE"}

package/lib/objects/ProcessParameter.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessParameter = exports.ProcessParameterType = void 0;
+const TM1Object_1 = require("./TM1Object");
+var ProcessParameterType;
+(function (ProcessParameterType) {
+    ProcessParameterType["String"] = "String";
+    ProcessParameterType["Numeric"] = "Numeric";
+})(ProcessParameterType || (exports.ProcessParameterType = ProcessParameterType = {}));
+class ProcessParameter extends TM1Object_1.TM1Object {
+    constructor(name, prompt = '', value = '', type = ProcessParameterType.String) {
+        super();
+        this._name = name;
+        this._prompt = prompt;
+        this._value = value;
+        this._type = type;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(name) {
+        this._name = name;
+    }
+    get prompt() {
+        return this._prompt;
+    }
+    set prompt(prompt) {
+        this._prompt = prompt;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(type) {
+        this._type = type;
+    }
+    get body() {
+        return JSON.stringify({
+            Name: this._name,
+            Prompt: this._prompt,
+            Value: this._value,
+            Type: this._type
+        });
+    }
+    static fromDict(parameterAsDict) {
+        return new ProcessParameter(parameterAsDict.Name, parameterAsDict.Prompt || '', parameterAsDict.Value || '', parameterAsDict.Type || ProcessParameterType.String);
+    }
+}
+exports.ProcessParameter = ProcessParameter;
+//# sourceMappingURL=ProcessParameter.js.map

package/lib/objects/ProcessVariable.d.ts

@@ -0,0 +1,26 @@
+import { TM1Object } from './TM1Object';
+export declare enum ProcessVariableType {
+    String = "String",
+    Numeric = "Numeric"
+}
+export declare class ProcessVariable extends TM1Object {
+    private _name;
+    private _type;
+    private _position;
+    private _startByte;
+    private _endByte;
+    constructor(name: string, type?: ProcessVariableType, position?: number, startByte?: number, endByte?: number);
+    get name(): string;
+    set name(name: string);
+    get type(): ProcessVariableType;
+    set type(type: ProcessVariableType);
+    get position(): number;
+    set position(position: number);
+    get startByte(): number;
+    set startByte(startByte: number);
+    get endByte(): number;
+    set endByte(endByte: number);
+    get body(): string;
+    static fromDict(variableAsDict: any): ProcessVariable;
+}
+//# sourceMappingURL=ProcessVariable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessVariable.d.ts","sourceRoot":"","sources":["../../src/objects/ProcessVariable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,oBAAY,mBAAmB;IAC3B,MAAM,WAAW;IACjB,OAAO,YAAY;CACtB;AAED,qBAAa,eAAgB,SAAQ,SAAS;IAC1C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAS;gBAGrB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,mBAAgD,EACtD,QAAQ,GAAE,MAAU,EACpB,SAAS,GAAE,MAAU,EACrB,OAAO,GAAE,MAAU;IAUvB,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,CAAC,IAAI,EAAE,MAAM,EAE3B;IAED,IAAW,IAAI,IAAI,mBAAmB,CAErC;IAED,IAAW,IAAI,CAAC,IAAI,EAAE,mBAAmB,EAExC;IAED,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,IAAW,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAEnC;IAED,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,SAAS,CAAC,SAAS,EAAE,MAAM,EAErC;IAED,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,OAAO,CAAC,OAAO,EAAE,MAAM,EAEjC;IAED,IAAW,IAAI,IAAI,MAAM,CAQxB;WAEa,QAAQ,CAAC,cAAc,EAAE,GAAG,GAAG,eAAe;CAS/D"}

package/lib/objects/ProcessVariable.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessVariable = exports.ProcessVariableType = void 0;
+const TM1Object_1 = require("./TM1Object");
+var ProcessVariableType;
+(function (ProcessVariableType) {
+    ProcessVariableType["String"] = "String";
+    ProcessVariableType["Numeric"] = "Numeric";
+})(ProcessVariableType || (exports.ProcessVariableType = ProcessVariableType = {}));
+class ProcessVariable extends TM1Object_1.TM1Object {
+    constructor(name, type = ProcessVariableType.String, position = 1, startByte = 1, endByte = 8) {
+        super();
+        this._name = name;
+        this._type = type;
+        this._position = position;
+        this._startByte = startByte;
+        this._endByte = endByte;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(name) {
+        this._name = name;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(type) {
+        this._type = type;
+    }
+    get position() {
+        return this._position;
+    }
+    set position(position) {
+        this._position = position;
+    }
+    get startByte() {
+        return this._startByte;
+    }
+    set startByte(startByte) {
+        this._startByte = startByte;
+    }
+    get endByte() {
+        return this._endByte;
+    }
+    set endByte(endByte) {
+        this._endByte = endByte;
+    }
+    get body() {
+        return JSON.stringify({
+            Name: this._name,
+            Type: this._type,
+            Position: this._position,
+            StartByte: this._startByte,
+            EndByte: this._endByte
+        });
+    }
+    static fromDict(variableAsDict) {
+        return new ProcessVariable(variableAsDict.Name, variableAsDict.Type || ProcessVariableType.String, variableAsDict.Position || 1, variableAsDict.StartByte || 1, variableAsDict.EndByte || 8);
+    }
+}
+exports.ProcessVariable = ProcessVariable;
+//# sourceMappingURL=ProcessVariable.js.map

package/lib/objects/Rules.d.ts

@@ -0,0 +1,30 @@
+import { TM1Object } from './TM1Object';
+export declare class Rules extends TM1Object {
+    /**
+     *     Abstraction of Rules on a cube.
+     *
+     *     rules_analytics
+     *         A collection of rulestatements, where each statement is stored in uppercase without linebreaks.
+     *         comments are not included.
+     *
+     */
+    static readonly KEYWORDS: string[];
+    private _text;
+    private _rulesAnalytics;
+    constructor(rules: string);
+    private initAnalytics;
+    get text(): string;
+    get rulesAnalytics(): string[];
+    get ruleStatements(): string[];
+    get feederStatements(): string[];
+    get skipcheck(): boolean;
+    get undefvals(): boolean;
+    get feedstrings(): boolean;
+    get hasFeeders(): boolean;
+    get body(): string;
+    get bodyAsDict(): any;
+    get length(): number;
+    [Symbol.iterator](): Iterator<string>;
+    toString(): string;
+}
+//# sourceMappingURL=Rules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Rules.d.ts","sourceRoot":"","sources":["../../src/objects/Rules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,qBAAa,KAAM,SAAQ,SAAS;IAChC;;;;;;;OAOG;IACH,gBAAuB,QAAQ,WAAwD;IAEvF,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,eAAe,CAAgB;gBAE3B,KAAK,EAAE,MAAM;IAQzB,OAAO,CAAC,aAAa;IAarB,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,cAAc,IAAI,MAAM,EAAE,CAEpC;IAED,IAAW,cAAc,IAAI,MAAM,EAAE,CAKpC;IAED,IAAW,gBAAgB,IAAI,MAAM,EAAE,CAKtC;IAED,IAAW,SAAS,IAAI,OAAO,CAO9B;IAED,IAAW,SAAS,IAAI,OAAO,CAO9B;IAED,IAAW,WAAW,IAAI,OAAO,CAOhC;IAED,IAAW,UAAU,IAAI,OAAO,CAQ/B;IAED,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,UAAU,IAAI,GAAG,CAE3B;IAED,IAAW,MAAM,IAAI,MAAM,CAE1B;IAGO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;IAItC,QAAQ,IAAI,MAAM;CAG5B"}

package/lib/objects/Rules.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rules = void 0;
+const TM1Object_1 = require("./TM1Object");
+class Rules extends TM1Object_1.TM1Object {
+    constructor(rules) {
+        super();
+        this._rulesAnalytics = [];
+        this._text = rules;
+        this._rulesAnalytics = [];
+        this.initAnalytics();
+    }
+    // this._rulesAnalytics serves for analysis on cube rules
+    initAnalytics() {
+        const textWithoutComments = this._text
+            .split('\n')
+            .filter(rule => rule.trim().length > 0 && rule.trim()[0] !== '#')
+            .join('\n');
+        for (const statement of textWithoutComments.split(';')) {
+            if (statement.trim().length > 0) {
+                this._rulesAnalytics.push(statement.replace(/\n/g, '').toUpperCase());
+            }
+        }
+    }
+    get text() {
+        return this._text;
+    }
+    get rulesAnalytics() {
+        return this._rulesAnalytics;
+    }
+    get ruleStatements() {
+        if (this.hasFeeders) {
+            return this.rulesAnalytics.slice(0, this._rulesAnalytics.indexOf('FEEDERS'));
+        }
+        return this.rulesAnalytics;
+    }
+    get feederStatements() {
+        if (this.hasFeeders) {
+            return this.rulesAnalytics.slice(this._rulesAnalytics.indexOf('FEEDERS') + 1);
+        }
+        return [];
+    }
+    get skipcheck() {
+        for (const rule of this._rulesAnalytics.slice(0, 5)) {
+            if (rule === 'SKIPCHECK') {
+                return true;
+            }
+        }
+        return false;
+    }
+    get undefvals() {
+        for (const rule of this._rulesAnalytics.slice(0, 5)) {
+            if (rule === 'UNDEFVALS') {
+                return true;
+            }
+        }
+        return false;
+    }
+    get feedstrings() {
+        for (const rule of this._rulesAnalytics.slice(0, 5)) {
+            if (rule === 'FEEDSTRINGS') {
+                return true;
+            }
+        }
+        return false;
+    }
+    get hasFeeders() {
+        if (this._rulesAnalytics.includes('FEEDERS')) {
+            // has feeders declaration
+            const feeders = this.rulesAnalytics.slice(this._rulesAnalytics.indexOf('FEEDERS'));
+            // has at least one actual feeder statement
+            return feeders.length > 1;
+        }
+        return false;
+    }
+    get body() {
+        return JSON.stringify(this.bodyAsDict);
+    }
+    get bodyAsDict() {
+        return { Rules: this.text };
+    }
+    get length() {
+        return this.rulesAnalytics.length;
+    }
+    // iterate through actual rule statements without linebreaks. Ignore comments.
+    *[Symbol.iterator]() {
+        yield* this.rulesAnalytics;
+    }
+    toString() {
+        return this.text;
+    }
+}
+exports.Rules = Rules;
+/**
+ *     Abstraction of Rules on a cube.
+ *
+ *     rules_analytics
+ *         A collection of rulestatements, where each statement is stored in uppercase without linebreaks.
+ *         comments are not included.
+ *
+ */
+Rules.KEYWORDS = ['SKIPCHECK', 'FEEDSTRINGS', 'UNDEFVALS', 'FEEDERS'];
+//# sourceMappingURL=Rules.js.map

package/lib/objects/Sandbox.d.ts

@@ -0,0 +1,21 @@
+import { TM1Object } from './TM1Object';
+export declare class Sandbox extends TM1Object {
+    /** Abstraction of a TM1 Sandbox
+     *
+     */
+    private _name;
+    private _includeInSandboxDimension;
+    loaded: boolean;
+    active: boolean;
+    queued: boolean;
+    constructor(name: string, includeInSandboxDimension?: boolean, loaded?: boolean, active?: boolean, queued?: boolean);
+    get name(): string;
+    set name(value: string);
+    get includeInSandboxDimension(): boolean;
+    set includeInSandboxDimension(value: boolean);
+    static fromJSON(sandboxAsJson: string): Sandbox;
+    static fromDict(sandboxAsDict: any): Sandbox;
+    get body(): string;
+    private constructBody;
+}
+//# sourceMappingURL=Sandbox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sandbox.d.ts","sourceRoot":"","sources":["../../src/objects/Sandbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,qBAAa,OAAQ,SAAQ,SAAS;IAClC;;OAEG;IAEH,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,0BAA0B,CAAW;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;gBAGnB,IAAI,EAAE,MAAM,EACZ,yBAAyB,GAAE,OAAc,EACzC,MAAM,GAAE,OAAe,EACvB,MAAM,GAAE,OAAe,EACvB,MAAM,GAAE,OAAe;IAgB3B,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,CAAC,KAAK,EAAE,MAAM,EAE5B;IAED,IAAW,yBAAyB,IAAI,OAAO,CAE9C;IAED,IAAW,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAElD;WAEa,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO;WAUxC,QAAQ,CAAC,aAAa,EAAE,GAAG,GAAG,OAAO;IAenD,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,OAAO,CAAC,aAAa;CAUxB"}

package/lib/objects/Sandbox.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sandbox = void 0;
+const TM1Object_1 = require("./TM1Object");
+class Sandbox extends TM1Object_1.TM1Object {
+    constructor(name, includeInSandboxDimension = true, loaded = false, active = false, queued = false) {
+        /**
+         *
+         * :param name: name of the Sandbox
+         * :param include_in_sandbox_dimension:
+         * :params loaded, active, queued: leave default as false when creating sandbox
+         */
+        super();
+        this.name = name;
+        this.includeInSandboxDimension = includeInSandboxDimension;
+        this.loaded = loaded;
+        this.active = active;
+        this.queued = queued;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get includeInSandboxDimension() {
+        return this._includeInSandboxDimension;
+    }
+    set includeInSandboxDimension(value) {
+        this._includeInSandboxDimension = value;
+    }
+    static fromJSON(sandboxAsJson) {
+        /** Alternative constructor
+         *
+         * :param sandbox_as_json: user as JSON string
+         * :return: sandbox, an instance of this class
+         */
+        const sandboxAsDict = JSON.parse(sandboxAsJson);
+        return Sandbox.fromDict(sandboxAsDict);
+    }
+    static fromDict(sandboxAsDict) {
+        /** Alternative constructor
+         *
+         * :param sandbox_as_dict: user as dict
+         * :return: an instance of this class
+         */
+        return new Sandbox(sandboxAsDict.Name, sandboxAsDict.IncludeInSandboxDimension, sandboxAsDict.IsLoaded, sandboxAsDict.IsActive, sandboxAsDict.IsQueued);
+    }
+    get body() {
+        return this.constructBody();
+    }
+    constructBody() {
+        /**
+         * construct body (json) from the class attributes
+         * :return: String, TM1 JSON representation of a sandbox
+         */
+        const bodyAsDict = {};
+        bodyAsDict.Name = this.name;
+        bodyAsDict.IncludeInSandboxDimension = this._includeInSandboxDimension;
+        return JSON.stringify(bodyAsDict);
+    }
+}
+exports.Sandbox = Sandbox;
+//# sourceMappingURL=Sandbox.js.map

package/lib/objects/Server.d.ts

@@ -0,0 +1,27 @@
+export declare class Server {
+    /** Abstraction of the TM1 Server
+     *
+     *    :Notes:
+     *        contains the information you get from http://localhost:5895/Servers
+     *        no methods so far
+     */
+    name: string;
+    ipAddress: string;
+    ipV6Address: string;
+    portNumber: number;
+    clientMessagePortNumber: number;
+    httpPortNumber: number;
+    usingSSL: boolean;
+    acceptingClients: boolean;
+    selfRegistered: boolean;
+    host: string;
+    isLocal: boolean;
+    sslCertificateId: string;
+    sslCertificateAuthority: string;
+    sslCertificateRevocationList: string;
+    clientExportSslServerKeyId: string;
+    clientExportSslServerCert: string;
+    lastUpdated: string;
+    constructor(serverAsDict: Record<string, any>);
+}
+//# sourceMappingURL=Server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Server.d.ts","sourceRoot":"","sources":["../../src/objects/Server.ts"],"names":[],"mappings":"AAAA,qBAAa,MAAM;IACf;;;;;OAKG;IACI,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,uBAAuB,EAAE,MAAM,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,uBAAuB,EAAE,MAAM,CAAC;IAChC,4BAA4B,EAAE,MAAM,CAAC;IACrC,0BAA0B,EAAE,MAAM,CAAC;IACnC,yBAAyB,EAAE,MAAM,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;gBAEf,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAmBhD"}

package/lib/objects/Server.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+class Server {
+    constructor(serverAsDict) {
+        this.name = serverAsDict['Name'];
+        this.ipAddress = serverAsDict['IPAddress'];
+        this.ipV6Address = serverAsDict['IPv6Address'];
+        this.portNumber = serverAsDict['PortNumber'];
+        this.clientMessagePortNumber = serverAsDict['ClientMessagePortNumber'];
+        this.httpPortNumber = serverAsDict['HTTPPortNumber'];
+        this.usingSSL = serverAsDict['UsingSSL'];
+        this.acceptingClients = serverAsDict['AcceptingClients'];
+        this.selfRegistered = serverAsDict['SelfRegistered'];
+        this.host = serverAsDict['Host'];
+        this.isLocal = serverAsDict['IsLocal'];
+        this.sslCertificateId = serverAsDict['SSLCertificateID'];
+        this.sslCertificateAuthority = serverAsDict['SSLCertificateAuthority'];
+        this.sslCertificateRevocationList = serverAsDict['SSLCertificateRevocationList'];
+        this.clientExportSslServerKeyId = serverAsDict['ClientExportSSLSvrKeyID'];
+        this.clientExportSslServerCert = serverAsDict['ClientExportSSLSvrCert'];
+        this.lastUpdated = serverAsDict['LastUpdated'];
+    }
+}
+exports.Server = Server;
+//# sourceMappingURL=Server.js.map