@arrowsphere/api-client 3.380.0 → 3.381.0-rc-cpe-1

package/build/monitoring/entities/alert/alert.d.ts

@@ -0,0 +1,69 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum AlertFrequencyEnum {
+    DAILY = "Daily",
+    MONTHLY = "Monthly",
+    WEEKLY = "Weekly",
+    ONE_TIME = "One time"
+}
+export declare enum AlertFormatEnum {
+    CSV = "csv",
+    XLSX = "xlsx"
+}
+export declare enum RenewalAlertWhenEnum {
+    END_OF_MONTH = "End of the month",
+    IN_TWO_MONTH = "In 2 Months",
+    IN_A_YEAR = "In a Year",
+    EXPIRED = "Expired"
+}
+export declare enum AlertFields {
+    COLUMN_ID = "id",
+    COLUMN_CATEGORY_ID = "categoryId",
+    COLUMN_NAME = "name",
+    COLUMN_FREQUENCY = "frequency",
+    COLUMN_RECIPIENT = "recipient",
+    COLUMN_FORMAT = "format",
+    COLUMN_FILTERS = "filters"
+}
+export declare type AlertType = {
+    [AlertFields.COLUMN_ID]: number;
+    [AlertFields.COLUMN_CATEGORY_ID]: number;
+    [AlertFields.COLUMN_NAME]: string;
+    [AlertFields.COLUMN_FREQUENCY]: AlertFrequencyEnum;
+    [AlertFields.COLUMN_RECIPIENT]: string;
+    [AlertFields.COLUMN_FORMAT]: AlertFormatEnum;
+    [AlertFields.COLUMN_FILTERS]: AlertFilters;
+};
+export declare enum AlertFiltersFields {
+    COLUMN_RENEWAL = "renewal"
+}
+export declare type AlertFilters = {
+    [AlertFiltersFields.COLUMN_RENEWAL]: RenewalFilters;
+};
+export declare enum FiltersFields {
+    COLUMN_END_CUSTOMERS = "endCustomers",
+    COLUMN_VENDOR = "vendor",
+    COLUMN_WHEN = "when",
+    COLUMN_CLASSIFICATION = "classification",
+    COLUMN_ONLY_AUTO_RENEWAL = "onlyAutoRenewal",
+    COLUMN_ONLY_PRICE_CHANGE = "onlyPriceChange"
+}
+export declare type RenewalFilters = {
+    [FiltersFields.COLUMN_END_CUSTOMERS]?: string[];
+    [FiltersFields.COLUMN_VENDOR]?: string;
+    [FiltersFields.COLUMN_WHEN]?: RenewalAlertWhenEnum;
+    [FiltersFields.COLUMN_CLASSIFICATION]?: string;
+    [FiltersFields.COLUMN_ONLY_AUTO_RENEWAL]?: boolean;
+    [FiltersFields.COLUMN_ONLY_PRICE_CHANGE]?: boolean;
+};
+export declare class Alert extends AbstractEntity<AlertType> {
+    #private;
+    constructor(data: AlertType);
+    get id(): number;
+    get categoryId(): number;
+    get name(): string;
+    get frequency(): AlertFrequencyEnum;
+    get recipient(): string;
+    get format(): AlertFormatEnum;
+    get filters(): AlertFilters;
+    toJSON(): AlertType;
+}

package/build/monitoring/entities/alert/alert.js

@@ -0,0 +1,112 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Alert_id, _Alert_categoryId, _Alert_name, _Alert_frequency, _Alert_recipient, _Alert_format, _Alert_filters;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alert = exports.FiltersFields = exports.AlertFiltersFields = exports.AlertFields = exports.RenewalAlertWhenEnum = exports.AlertFormatEnum = exports.AlertFrequencyEnum = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var AlertFrequencyEnum;
+(function (AlertFrequencyEnum) {
+    AlertFrequencyEnum["DAILY"] = "Daily";
+    AlertFrequencyEnum["MONTHLY"] = "Monthly";
+    AlertFrequencyEnum["WEEKLY"] = "Weekly";
+    AlertFrequencyEnum["ONE_TIME"] = "One time";
+})(AlertFrequencyEnum = exports.AlertFrequencyEnum || (exports.AlertFrequencyEnum = {}));
+var AlertFormatEnum;
+(function (AlertFormatEnum) {
+    AlertFormatEnum["CSV"] = "csv";
+    AlertFormatEnum["XLSX"] = "xlsx";
+})(AlertFormatEnum = exports.AlertFormatEnum || (exports.AlertFormatEnum = {}));
+var RenewalAlertWhenEnum;
+(function (RenewalAlertWhenEnum) {
+    RenewalAlertWhenEnum["END_OF_MONTH"] = "End of the month";
+    RenewalAlertWhenEnum["IN_TWO_MONTH"] = "In 2 Months";
+    RenewalAlertWhenEnum["IN_A_YEAR"] = "In a Year";
+    RenewalAlertWhenEnum["EXPIRED"] = "Expired";
+})(RenewalAlertWhenEnum = exports.RenewalAlertWhenEnum || (exports.RenewalAlertWhenEnum = {}));
+var AlertFields;
+(function (AlertFields) {
+    AlertFields["COLUMN_ID"] = "id";
+    AlertFields["COLUMN_CATEGORY_ID"] = "categoryId";
+    AlertFields["COLUMN_NAME"] = "name";
+    AlertFields["COLUMN_FREQUENCY"] = "frequency";
+    AlertFields["COLUMN_RECIPIENT"] = "recipient";
+    AlertFields["COLUMN_FORMAT"] = "format";
+    AlertFields["COLUMN_FILTERS"] = "filters";
+})(AlertFields = exports.AlertFields || (exports.AlertFields = {}));
+var AlertFiltersFields;
+(function (AlertFiltersFields) {
+    AlertFiltersFields["COLUMN_RENEWAL"] = "renewal";
+})(AlertFiltersFields = exports.AlertFiltersFields || (exports.AlertFiltersFields = {}));
+var FiltersFields;
+(function (FiltersFields) {
+    FiltersFields["COLUMN_END_CUSTOMERS"] = "endCustomers";
+    FiltersFields["COLUMN_VENDOR"] = "vendor";
+    FiltersFields["COLUMN_WHEN"] = "when";
+    FiltersFields["COLUMN_CLASSIFICATION"] = "classification";
+    FiltersFields["COLUMN_ONLY_AUTO_RENEWAL"] = "onlyAutoRenewal";
+    FiltersFields["COLUMN_ONLY_PRICE_CHANGE"] = "onlyPriceChange";
+})(FiltersFields = exports.FiltersFields || (exports.FiltersFields = {}));
+class Alert extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        _Alert_id.set(this, void 0);
+        _Alert_categoryId.set(this, void 0);
+        _Alert_name.set(this, void 0);
+        _Alert_frequency.set(this, void 0);
+        _Alert_recipient.set(this, void 0);
+        _Alert_format.set(this, void 0);
+        _Alert_filters.set(this, void 0);
+        __classPrivateFieldSet(this, _Alert_id, data.id, "f");
+        __classPrivateFieldSet(this, _Alert_categoryId, data.categoryId, "f");
+        __classPrivateFieldSet(this, _Alert_name, data.name, "f");
+        __classPrivateFieldSet(this, _Alert_frequency, data.frequency, "f");
+        __classPrivateFieldSet(this, _Alert_recipient, data.recipient, "f");
+        __classPrivateFieldSet(this, _Alert_format, data.format, "f");
+        __classPrivateFieldSet(this, _Alert_filters, data.filters, "f");
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _Alert_id, "f");
+    }
+    get categoryId() {
+        return __classPrivateFieldGet(this, _Alert_categoryId, "f");
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _Alert_name, "f");
+    }
+    get frequency() {
+        return __classPrivateFieldGet(this, _Alert_frequency, "f");
+    }
+    get recipient() {
+        return __classPrivateFieldGet(this, _Alert_recipient, "f");
+    }
+    get format() {
+        return __classPrivateFieldGet(this, _Alert_format, "f");
+    }
+    get filters() {
+        return __classPrivateFieldGet(this, _Alert_filters, "f");
+    }
+    toJSON() {
+        return {
+            [AlertFields.COLUMN_ID]: this.id,
+            [AlertFields.COLUMN_CATEGORY_ID]: this.categoryId,
+            [AlertFields.COLUMN_NAME]: this.name,
+            [AlertFields.COLUMN_FREQUENCY]: this.frequency,
+            [AlertFields.COLUMN_RECIPIENT]: this.recipient,
+            [AlertFields.COLUMN_FORMAT]: this.format,
+            [AlertFields.COLUMN_FILTERS]: this.filters,
+        };
+    }
+}
+exports.Alert = Alert;
+_Alert_id = new WeakMap(), _Alert_categoryId = new WeakMap(), _Alert_name = new WeakMap(), _Alert_frequency = new WeakMap(), _Alert_recipient = new WeakMap(), _Alert_format = new WeakMap(), _Alert_filters = new WeakMap();
+//# sourceMappingURL=alert.js.map

package/build/monitoring/entities/alert/createAlert.d.ts

@@ -0,0 +1,13 @@
+import { AbstractEntity } from '../../../abstractEntity';
+export declare enum CreateAlertFields {
+    COLUMN_ALERT_ID = "alertId"
+}
+export declare type CreateAlertType = {
+    [CreateAlertFields.COLUMN_ALERT_ID]: number;
+};
+export declare class CreateAlert extends AbstractEntity<CreateAlertType> {
+    #private;
+    constructor(data: CreateAlertType);
+    get alertId(): number;
+    toJSON(): CreateAlertType;
+}

package/build/monitoring/entities/alert/createAlert.js

@@ -0,0 +1,38 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CreateAlert_alertId;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAlert = exports.CreateAlertFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var CreateAlertFields;
+(function (CreateAlertFields) {
+    CreateAlertFields["COLUMN_ALERT_ID"] = "alertId";
+})(CreateAlertFields = exports.CreateAlertFields || (exports.CreateAlertFields = {}));
+class CreateAlert extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        _CreateAlert_alertId.set(this, void 0);
+        __classPrivateFieldSet(this, _CreateAlert_alertId, data.alertId, "f");
+    }
+    get alertId() {
+        return __classPrivateFieldGet(this, _CreateAlert_alertId, "f");
+    }
+    toJSON() {
+        return {
+            [CreateAlertFields.COLUMN_ALERT_ID]: this.alertId,
+        };
+    }
+}
+exports.CreateAlert = CreateAlert;
+_CreateAlert_alertId = new WeakMap();
+//# sourceMappingURL=createAlert.js.map

package/build/monitoring/entities/alert/listAlert.d.ts

@@ -0,0 +1,9 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { Alert, AlertType } from './alert';
+export declare type AlertListType = Array<AlertType>;
+export declare class AlertList extends AbstractEntity<AlertListType> {
+    #private;
+    constructor(data: Array<AlertType>);
+    get alertList(): Array<Alert>;
+    toJSON(): AlertListType;
+}

package/build/monitoring/entities/alert/listAlert.js

@@ -0,0 +1,33 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AlertList_alertList;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertList = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const alert_1 = require("./alert");
+class AlertList extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        _AlertList_alertList.set(this, void 0);
+        __classPrivateFieldSet(this, _AlertList_alertList, data.map((alert) => new alert_1.Alert(alert)), "f");
+    }
+    get alertList() {
+        return __classPrivateFieldGet(this, _AlertList_alertList, "f");
+    }
+    toJSON() {
+        return this.alertList.map((alert) => alert.toJSON());
+    }
+}
+exports.AlertList = AlertList;
+_AlertList_alertList = new WeakMap();
+//# sourceMappingURL=listAlert.js.map

package/build/monitoring/index.d.ts

@@ -1 +1,4 @@
 export * from './monitoringClient';
+export * from './entities/alert/alert';
+export * from './entities/alert/createAlert';
+export * from './entities/alert/listAlert';

package/build/monitoring/index.js

@@ -15,4 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./monitoringClient"), exports);
+__exportStar(require("./entities/alert/alert"), exports);
+__exportStar(require("./entities/alert/createAlert"), exports);
+__exportStar(require("./entities/alert/listAlert"), exports);
 //# sourceMappingURL=index.js.map

package/build/monitoring/monitoringClient.d.ts

@@ -1,4 +1,8 @@
-import { AbstractRestfulClient } from '../abstractRestfulClient';
+import { AbstractRestfulClient, Parameters } from '../abstractRestfulClient';
+import { Alert, AlertFields, AlertFilters, AlertFormatEnum, AlertFrequencyEnum } from './entities/alert/alert';
+import { CreateAlert } from './entities/alert/createAlert';
+import { GetResult } from '../getResult';
+import { AlertList } from './entities/alert/listAlert';
 export declare type ReportMonitoringType = {
     body: {
         [keys in string]: string | number | null;
@@ -7,6 +11,15 @@ export declare type ReportMonitoringType = {
     userAgent: string;
     type: string;
 };
+export declare type CreateAlertPayload = {
+    [AlertFields.COLUMN_CATEGORY_ID]: number;
+    [AlertFields.COLUMN_NAME]: string;
+    [AlertFields.COLUMN_FREQUENCY]: AlertFrequencyEnum;
+    [AlertFields.COLUMN_RECIPIENT]: string;
+    [AlertFields.COLUMN_FORMAT]: AlertFormatEnum;
+    [AlertFields.COLUMN_FILTERS]: AlertFilters;
+};
+export declare type UpdateAlertPayload = Partial<Omit<CreateAlertPayload, AlertFields.COLUMN_CATEGORY_ID>>;
 export declare class MonitoringClient extends AbstractRestfulClient {
     /**
      * The base path of the API
@@ -16,5 +29,14 @@ export declare class MonitoringClient extends AbstractRestfulClient {
      * The path of the report endpoint
      */
     private REPORT_PATH;
+    /**
+     * The path of the alert endpoint
+     */
+    private ALERT_PATH;
     sendReport(report: ReportMonitoringType): Promise<void>;
+    createAlert(payload: CreateAlertPayload): Promise<GetResult<CreateAlert>>;
+    listAlerts(parameters?: Parameters): Promise<GetResult<AlertList>>;
+    getAlert(alertId: number): Promise<GetResult<Alert>>;
+    updateAlert(alertId: number, payload: UpdateAlertPayload): Promise<GetResult<Alert>>;
+    deleteAlert(alertId: number): Promise<void>;
 }

package/build/monitoring/monitoringClient.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MonitoringClient = void 0;
 const abstractRestfulClient_1 = require("../abstractRestfulClient");
+const alert_1 = require("./entities/alert/alert");
 class MonitoringClient extends abstractRestfulClient_1.AbstractRestfulClient {
     constructor() {
         super(...arguments);
@@ -13,11 +14,35 @@ class MonitoringClient extends abstractRestfulClient_1.AbstractRestfulClient {
          * The path of the report endpoint
          */
         this.REPORT_PATH = '/report';
+        /**
+         * The path of the alert endpoint
+         */
+        this.ALERT_PATH = '/alerts';
     }
     sendReport(report) {
         this.path = this.REPORT_PATH;
         return this.post(report);
     }
+    createAlert(payload) {
+        this.path = this.ALERT_PATH;
+        return this.post(payload);
+    }
+    listAlerts(parameters = {}) {
+        this.path = this.ALERT_PATH;
+        return this.get(parameters);
+    }
+    getAlert(alertId) {
+        this.path = this.ALERT_PATH + `/${alertId}`;
+        return this.get();
+    }
+    updateAlert(alertId, payload) {
+        this.path = this.ALERT_PATH + `/${alertId}`;
+        return this.patch(payload);
+    }
+    deleteAlert(alertId) {
+        this.path = this.ALERT_PATH + `/${alertId}`;
+        return this.delete();
+    }
 }
 exports.MonitoringClient = MonitoringClient;
 //# sourceMappingURL=monitoringClient.js.map

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/ArrowSphere/nodejs-api-client.git"
   },
-  "version": "3.380.0",
+  "version": "3.381.0-rc-cpe-1",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",