@arrowsphere/api-client 3.7.0 → 3.9.0-rc.0

package/build/consumption/entities/bi/consumptionBI.js

@@ -0,0 +1,70 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _currency, _period, _aggregate, _metric, _top;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsumptionBI = exports.ConsumptionBIFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const period_1 = require("./period/period");
+const top_1 = require("./top/top");
+var ConsumptionBIFields;
+(function (ConsumptionBIFields) {
+    ConsumptionBIFields["COLUMN_CURRENCY"] = "currency";
+    ConsumptionBIFields["COLUMN_PERIOD"] = "period";
+    ConsumptionBIFields["COLUMN_AGGREGATE"] = "aggregate";
+    ConsumptionBIFields["COLUMN_METRIC"] = "metric";
+    ConsumptionBIFields["COLUMN_TOP"] = "top";
+})(ConsumptionBIFields = exports.ConsumptionBIFields || (exports.ConsumptionBIFields = {}));
+class ConsumptionBI extends abstractEntity_1.AbstractEntity {
+    constructor(consumptionResponse) {
+        super(consumptionResponse);
+        _currency.set(this, void 0);
+        _period.set(this, void 0);
+        _aggregate.set(this, void 0);
+        _metric.set(this, void 0);
+        _top.set(this, void 0);
+        __classPrivateFieldSet(this, _currency, consumptionResponse[ConsumptionBIFields.COLUMN_CURRENCY]);
+        __classPrivateFieldSet(this, _period, new period_1.Period(consumptionResponse[ConsumptionBIFields.COLUMN_PERIOD]));
+        __classPrivateFieldSet(this, _aggregate, consumptionResponse[ConsumptionBIFields.COLUMN_AGGREGATE]);
+        __classPrivateFieldSet(this, _metric, consumptionResponse[ConsumptionBIFields.COLUMN_METRIC]);
+        __classPrivateFieldSet(this, _top, consumptionResponse[ConsumptionBIFields.COLUMN_TOP].map((top) => new top_1.Top(top)));
+    }
+    get currency() {
+        return __classPrivateFieldGet(this, _currency);
+    }
+    get period() {
+        return __classPrivateFieldGet(this, _period);
+    }
+    get aggregate() {
+        return __classPrivateFieldGet(this, _aggregate);
+    }
+    get metric() {
+        return __classPrivateFieldGet(this, _metric);
+    }
+    get top() {
+        return __classPrivateFieldGet(this, _top);
+    }
+    toJSON() {
+        return {
+            [ConsumptionBIFields.COLUMN_CURRENCY]: this.currency,
+            [ConsumptionBIFields.COLUMN_PERIOD]: this.period.toJSON(),
+            [ConsumptionBIFields.COLUMN_AGGREGATE]: this.aggregate,
+            [ConsumptionBIFields.COLUMN_METRIC]: this.metric,
+            [ConsumptionBIFields.COLUMN_TOP]: this.top.map((top) => top.toJSON()),
+        };
+    }
+}
+exports.ConsumptionBI = ConsumptionBI;
+_currency = new WeakMap(), _period = new WeakMap(), _aggregate = new WeakMap(), _metric = new WeakMap(), _top = new WeakMap();
+//# sourceMappingURL=consumptionBI.js.map

package/build/consumption/entities/bi/period/period.d.ts

@@ -0,0 +1,16 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum PeriodFields {
+    COLUMN_FROM = "from",
+    COLUMN_TO = "to"
+}
+export declare type PeriodType = {
+    [PeriodFields.COLUMN_FROM]: string;
+    [PeriodFields.COLUMN_TO]: string;
+};
+export declare class Period extends AbstractEntity<PeriodType> {
+    #private;
+    constructor(periodResponse: PeriodType);
+    get from(): string;
+    get to(): string;
+    toJSON(): PeriodType;
+}

package/build/consumption/entities/bi/period/period.js

@@ -0,0 +1,47 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _from, _to;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Period = exports.PeriodFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var PeriodFields;
+(function (PeriodFields) {
+    PeriodFields["COLUMN_FROM"] = "from";
+    PeriodFields["COLUMN_TO"] = "to";
+})(PeriodFields = exports.PeriodFields || (exports.PeriodFields = {}));
+class Period extends abstractEntity_1.AbstractEntity {
+    constructor(periodResponse) {
+        super(periodResponse);
+        _from.set(this, void 0);
+        _to.set(this, void 0);
+        __classPrivateFieldSet(this, _from, periodResponse[PeriodFields.COLUMN_FROM]);
+        __classPrivateFieldSet(this, _to, periodResponse[PeriodFields.COLUMN_TO]);
+    }
+    get from() {
+        return __classPrivateFieldGet(this, _from);
+    }
+    get to() {
+        return __classPrivateFieldGet(this, _to);
+    }
+    toJSON() {
+        return {
+            [PeriodFields.COLUMN_FROM]: this.from,
+            [PeriodFields.COLUMN_TO]: this.to,
+        };
+    }
+}
+exports.Period = Period;
+_from = new WeakMap(), _to = new WeakMap();
+//# sourceMappingURL=period.js.map

package/build/consumption/entities/bi/top/top.d.ts

@@ -0,0 +1,22 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum TopFields {
+    COLUMN_RANK = "rank",
+    COLUMN_METRIC = "metric",
+    COLUMN_NAME = "name",
+    COLUMN_REF = "ref"
+}
+export declare type TopType = {
+    [TopFields.COLUMN_RANK]: string;
+    [TopFields.COLUMN_METRIC]: number;
+    [TopFields.COLUMN_NAME]: string;
+    [TopFields.COLUMN_REF]: string;
+};
+export declare class Top extends AbstractEntity<TopType> {
+    #private;
+    constructor(topResponse: TopType);
+    get rank(): string;
+    get metric(): number;
+    get name(): string;
+    get ref(): string;
+    toJSON(): TopType;
+}

package/build/consumption/entities/bi/top/top.js

@@ -0,0 +1,61 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _rank, _metric, _name, _ref;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Top = exports.TopFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var TopFields;
+(function (TopFields) {
+    TopFields["COLUMN_RANK"] = "rank";
+    TopFields["COLUMN_METRIC"] = "metric";
+    TopFields["COLUMN_NAME"] = "name";
+    TopFields["COLUMN_REF"] = "ref";
+})(TopFields = exports.TopFields || (exports.TopFields = {}));
+class Top extends abstractEntity_1.AbstractEntity {
+    constructor(topResponse) {
+        super(topResponse);
+        _rank.set(this, void 0);
+        _metric.set(this, void 0);
+        _name.set(this, void 0);
+        _ref.set(this, void 0);
+        __classPrivateFieldSet(this, _rank, topResponse[TopFields.COLUMN_RANK]);
+        __classPrivateFieldSet(this, _metric, topResponse[TopFields.COLUMN_METRIC]);
+        __classPrivateFieldSet(this, _name, topResponse[TopFields.COLUMN_NAME]);
+        __classPrivateFieldSet(this, _ref, topResponse[TopFields.COLUMN_REF]);
+    }
+    get rank() {
+        return __classPrivateFieldGet(this, _rank);
+    }
+    get metric() {
+        return __classPrivateFieldGet(this, _metric);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name);
+    }
+    get ref() {
+        return __classPrivateFieldGet(this, _ref);
+    }
+    toJSON() {
+        return {
+            [TopFields.COLUMN_RANK]: this.rank,
+            [TopFields.COLUMN_METRIC]: this.metric,
+            [TopFields.COLUMN_NAME]: this.name,
+            [TopFields.COLUMN_REF]: this.ref,
+        };
+    }
+}
+exports.Top = Top;
+_rank = new WeakMap(), _metric = new WeakMap(), _name = new WeakMap(), _ref = new WeakMap();
+//# sourceMappingURL=top.js.map

package/build/consumption/entities/consumption/consumption.d.ts

@@ -0,0 +1,16 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum ConsumptionFields {
+    COLUMN_HEADERS = "headers",
+    COLUMN_LINES = "lines"
+}
+export declare type ConsumptionType = {
+    [ConsumptionFields.COLUMN_HEADERS]: Array<string>;
+    [ConsumptionFields.COLUMN_LINES]: Array<string | number>;
+};
+export declare class Consumption extends AbstractEntity<ConsumptionType> {
+    #private;
+    constructor(consumptionResponse: ConsumptionType);
+    get headers(): Array<string>;
+    get lines(): Array<string | number>;
+    toJSON(): ConsumptionType;
+}

package/build/consumption/entities/consumption/consumption.js

@@ -0,0 +1,47 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _headers, _lines;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumption = exports.ConsumptionFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var ConsumptionFields;
+(function (ConsumptionFields) {
+    ConsumptionFields["COLUMN_HEADERS"] = "headers";
+    ConsumptionFields["COLUMN_LINES"] = "lines";
+})(ConsumptionFields = exports.ConsumptionFields || (exports.ConsumptionFields = {}));
+class Consumption extends abstractEntity_1.AbstractEntity {
+    constructor(consumptionResponse) {
+        super(consumptionResponse);
+        _headers.set(this, void 0);
+        _lines.set(this, void 0);
+        __classPrivateFieldSet(this, _headers, consumptionResponse[ConsumptionFields.COLUMN_HEADERS]);
+        __classPrivateFieldSet(this, _lines, consumptionResponse[ConsumptionFields.COLUMN_LINES]);
+    }
+    get headers() {
+        return __classPrivateFieldGet(this, _headers);
+    }
+    get lines() {
+        return __classPrivateFieldGet(this, _lines);
+    }
+    toJSON() {
+        return {
+            [ConsumptionFields.COLUMN_HEADERS]: this.headers,
+            [ConsumptionFields.COLUMN_LINES]: this.lines,
+        };
+    }
+}
+exports.Consumption = Consumption;
+_headers = new WeakMap(), _lines = new WeakMap();
+//# sourceMappingURL=consumption.js.map

package/build/consumption/index.d.ts

@@ -0,0 +1,5 @@
+export * from './entities/consumption/consumption';
+export * from './entities/bi/period/period';
+export * from './entities/bi/top/top';
+export * from './entities/bi/consumptionBI';
+export * from './consumptionClient';

package/build/consumption/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entities/consumption/consumption"), exports);
+__exportStar(require("./entities/bi/period/period"), exports);
+__exportStar(require("./entities/bi/top/top"), exports);
+__exportStar(require("./entities/bi/consumptionBI"), exports);
+__exportStar(require("./consumptionClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/index.d.ts

@@ -4,7 +4,9 @@ export * from './publicGraphQLClient';
 export * from './abstractEntity';
 export * from './abstractClient';
 export * from './abstractGraphQLClient';
+export * from './campaign/';
 export * from './catalog/';
+export * from './consumption';
 export { ContactInformation };
 export * from './customers/';
 export * from './general/';

package/build/index.js

@@ -30,7 +30,9 @@ __exportStar(require("./publicGraphQLClient"), exports);
 __exportStar(require("./abstractEntity"), exports);
 __exportStar(require("./abstractClient"), exports);
 __exportStar(require("./abstractGraphQLClient"), exports);
+__exportStar(require("./campaign/"), exports);
 __exportStar(require("./catalog/"), exports);
+__exportStar(require("./consumption"), exports);
 __exportStar(require("./customers/"), exports);
 __exportStar(require("./general/"), exports);
 __exportStar(require("./licenses/"), exports);

package/build/publicApiClient.d.ts

@@ -5,6 +5,8 @@ import { SubscriptionsClient } from './subscriptions/subscriptionsClient';
 import { CustomersClient } from './customers/customersClient';
 import { OrdersClient } from './orders';
 import { ContactClient } from './contact/contactClient';
+import { CampaignClient } from './campaign';
+import { ConsumptionClient } from './consumption/consumptionClient';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -45,5 +47,11 @@ export declare class PublicApiClient extends AbstractClient {
      * @returns {@link ContactClient}
      */
     getContactClient(): ContactClient;
+    /**
+     * Creates a new {@link ContactClient} instance and returns it
+     * @returns {@link ContactClient}
+     */
+    getCampaignClient(): CampaignClient;
+    getConsumptionClient(): ConsumptionClient;
 }
 export default PublicApiClient;

package/build/publicApiClient.js

@@ -8,6 +8,8 @@ const subscriptionsClient_1 = require("./subscriptions/subscriptionsClient");
 const customersClient_1 = require("./customers/customersClient");
 const orders_1 = require("./orders");
 const contactClient_1 = require("./contact/contactClient");
+const campaign_1 = require("./campaign");
+const consumptionClient_1 = require("./consumption/consumptionClient");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -78,6 +80,20 @@ class PublicApiClient extends abstractClient_1.AbstractClient {
             .setUrl(this.url)
             .setApiKey(this.apiKey);
     }
+    /**
+     * Creates a new {@link ContactClient} instance and returns it
+     * @returns {@link ContactClient}
+     */
+    getCampaignClient() {
+        return new campaign_1.CampaignClient(this.client)
+            .setUrl(this.url)
+            .setApiKey(this.apiKey);
+    }
+    getConsumptionClient() {
+        return new consumptionClient_1.ConsumptionClient(this.client)
+            .setUrl(this.url)
+            .setApiKey(this.apiKey);
+    }
 }
 exports.PublicApiClient = PublicApiClient;
 exports.default = PublicApiClient;

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/ArrowSphere/nodejs-api-client.git"
   },
-  "version": "3.7.0",
+  "version": "3.9.0-rc.0",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -81,7 +81,7 @@
     "@types/validatorjs": "3.15.0",
     "axios": "0.21.1",
     "graphql": "^16.3.0",
-    "graphql-request": "^4.0.0",
+    "graphql-request": "4.2.0",
     "validatorjs": "3.22.1"
   }
 }