@arrowsphere/api-client 1.0.0 → 2.0.0

package/build/licenses/entities/offer/priceband/identifiersFindResult.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 _arrowsphere;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifiersFindResult = exports.IdentifiersFindResultFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+const arrowsphereFindResult_1 = require("./identifiers/arrowsphereFindResult");
+var IdentifiersFindResultFields;
+(function (IdentifiersFindResultFields) {
+    IdentifiersFindResultFields["COLUMN_ARROWSPHERE"] = "arrowsphere";
+})(IdentifiersFindResultFields = exports.IdentifiersFindResultFields || (exports.IdentifiersFindResultFields = {}));
+class IdentifiersFindResult extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        this.VALIDATION_RULES = {
+            [IdentifiersFindResultFields.COLUMN_ARROWSPHERE]: 'present|array',
+        };
+        _arrowsphere.set(this, void 0);
+        const arrowsphere = {
+            [arrowsphereFindResult_1.ArrowsphereFindResultFields.COLUMN_SKU]: data[IdentifiersFindResultFields.COLUMN_ARROWSPHERE][arrowsphereFindResult_1.ArrowsphereFindResultFields.COLUMN_SKU],
+        };
+        __classPrivateFieldSet(this, _arrowsphere, new arrowsphereFindResult_1.ArrowsphereFindResult(arrowsphere));
+    }
+    get arrowsphere() {
+        return __classPrivateFieldGet(this, _arrowsphere);
+    }
+    toJSON() {
+        return {
+            [IdentifiersFindResultFields.COLUMN_ARROWSPHERE]: this.arrowsphere.toJSON(),
+        };
+    }
+}
+exports.IdentifiersFindResult = IdentifiersFindResult;
+_arrowsphere = new WeakMap();
+//# sourceMappingURL=identifiersFindResult.js.map

package/build/licenses/entities/offer/priceband/priceBandActionFlagsFindResult.d.ts

@@ -0,0 +1,49 @@
+import { DataKeywords, FiltersParameters, SortParameters } from '../../../licensesClient';
+import { AbstractEntity } from '../../../../abstractEntity';
+import { Rules } from 'validatorjs';
+export declare enum PriceBandActionFlagsFindResultFields {
+    COLUMN_CAN_BE_CANCELLED = "canBeCancelled",
+    COLUMN_CAN_BE_REACTIVATED = "canBeReactivated",
+    COLUMN_CAN_BE_SUSPENDED = "canBeSuspended",
+    COLUMN_CAN_DECREASE_SEATS = "canDecreaseSeats",
+    COLUMN_CAN_INCREASE_SEATS = "canIncreaseSeats"
+}
+export declare type PriceBandActionFlagsFindResultData = {
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_CANCELLED]: boolean;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_REACTIVATED]: boolean;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_SUSPENDED]: boolean;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_DECREASE_SEATS]: boolean;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_INCREASE_SEATS]: boolean;
+};
+export declare type PriceBandActionFlagsFindResultDataKeywords = {
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_CANCELLED]?: DataKeywords;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_REACTIVATED]?: DataKeywords;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_SUSPENDED]?: DataKeywords;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_DECREASE_SEATS]?: DataKeywords;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_INCREASE_SEATS]?: DataKeywords;
+};
+export declare type PriceBandActionFlagsDataFindResultSortParameters = {
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_CANCELLED]?: SortParameters;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_REACTIVATED]?: SortParameters;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_SUSPENDED]?: SortParameters;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_DECREASE_SEATS]?: SortParameters;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_INCREASE_SEATS]?: SortParameters;
+};
+export declare type PriceBandActionFlagsFindResultDataFiltersParameters = {
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_CANCELLED]?: FiltersParameters;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_REACTIVATED]?: FiltersParameters;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_SUSPENDED]?: FiltersParameters;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_DECREASE_SEATS]?: FiltersParameters;
+    [PriceBandActionFlagsFindResultFields.COLUMN_CAN_INCREASE_SEATS]?: FiltersParameters;
+};
+export declare class PriceBandActionFlagsFindResult extends AbstractEntity<PriceBandActionFlagsFindResultData> {
+    #private;
+    protected VALIDATION_RULES: Rules;
+    constructor(data: PriceBandActionFlagsFindResultData);
+    get canBeCancelled(): boolean;
+    get canBeReactivated(): boolean;
+    get canBeSuspended(): boolean;
+    get canDecreaseSeats(): boolean;
+    get canIncreaseSeats(): boolean;
+    toJSON(): PriceBandActionFlagsFindResultData;
+}

package/build/licenses/entities/offer/priceband/priceBandActionFlagsFindResult.js

@@ -0,0 +1,80 @@
+"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 _canBeCancelled, _canBeReactivated, _canBeSuspended, _canDecreaseSeats, _canIncreaseSeats;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceBandActionFlagsFindResult = exports.PriceBandActionFlagsFindResultFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var PriceBandActionFlagsFindResultFields;
+(function (PriceBandActionFlagsFindResultFields) {
+    PriceBandActionFlagsFindResultFields["COLUMN_CAN_BE_CANCELLED"] = "canBeCancelled";
+    PriceBandActionFlagsFindResultFields["COLUMN_CAN_BE_REACTIVATED"] = "canBeReactivated";
+    PriceBandActionFlagsFindResultFields["COLUMN_CAN_BE_SUSPENDED"] = "canBeSuspended";
+    PriceBandActionFlagsFindResultFields["COLUMN_CAN_DECREASE_SEATS"] = "canDecreaseSeats";
+    PriceBandActionFlagsFindResultFields["COLUMN_CAN_INCREASE_SEATS"] = "canIncreaseSeats";
+})(PriceBandActionFlagsFindResultFields = exports.PriceBandActionFlagsFindResultFields || (exports.PriceBandActionFlagsFindResultFields = {}));
+class PriceBandActionFlagsFindResult extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        this.VALIDATION_RULES = {
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_CANCELLED]: 'required|boolean',
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_REACTIVATED]: 'required|boolean',
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_SUSPENDED]: 'required|boolean',
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_DECREASE_SEATS]: 'required|boolean',
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_INCREASE_SEATS]: 'required|boolean',
+        };
+        _canBeCancelled.set(this, void 0);
+        _canBeReactivated.set(this, void 0);
+        _canBeSuspended.set(this, void 0);
+        _canDecreaseSeats.set(this, void 0);
+        _canIncreaseSeats.set(this, void 0);
+        __classPrivateFieldSet(this, _canBeCancelled, data[PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_CANCELLED]);
+        __classPrivateFieldSet(this, _canBeReactivated, data[PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_REACTIVATED]);
+        __classPrivateFieldSet(this, _canBeSuspended, data[PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_SUSPENDED]);
+        __classPrivateFieldSet(this, _canDecreaseSeats, data[PriceBandActionFlagsFindResultFields.COLUMN_CAN_DECREASE_SEATS]);
+        __classPrivateFieldSet(this, _canIncreaseSeats, data[PriceBandActionFlagsFindResultFields.COLUMN_CAN_INCREASE_SEATS]);
+    }
+    get canBeCancelled() {
+        return __classPrivateFieldGet(this, _canBeCancelled);
+    }
+    get canBeReactivated() {
+        return __classPrivateFieldGet(this, _canBeReactivated);
+    }
+    get canBeSuspended() {
+        return __classPrivateFieldGet(this, _canBeSuspended);
+    }
+    get canDecreaseSeats() {
+        return __classPrivateFieldGet(this, _canDecreaseSeats);
+    }
+    get canIncreaseSeats() {
+        return __classPrivateFieldGet(this, _canIncreaseSeats);
+    }
+    toJSON() {
+        return {
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_CANCELLED]: this
+                .canBeCancelled,
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_REACTIVATED]: this
+                .canBeReactivated,
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_SUSPENDED]: this
+                .canBeSuspended,
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_DECREASE_SEATS]: this
+                .canDecreaseSeats,
+            [PriceBandActionFlagsFindResultFields.COLUMN_CAN_INCREASE_SEATS]: this
+                .canIncreaseSeats,
+        };
+    }
+}
+exports.PriceBandActionFlagsFindResult = PriceBandActionFlagsFindResult;
+_canBeCancelled = new WeakMap(), _canBeReactivated = new WeakMap(), _canBeSuspended = new WeakMap(), _canDecreaseSeats = new WeakMap(), _canIncreaseSeats = new WeakMap();
+//# sourceMappingURL=priceBandActionFlagsFindResult.js.map

package/build/licenses/entities/offer/priceband/priceBandPriceFindResult.d.ts

@@ -0,0 +1,37 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+import { Rules } from 'validatorjs';
+import { DataKeywords, FiltersParameters, SortParameters } from '../../../licensesClient';
+export declare enum PriceBandPriceFindResultFields {
+    COLUMN_BUY = "buy",
+    COLUMN_SELL = "sell",
+    COLUMN_PUBLIC = "public"
+}
+export declare type PriceBandPriceFindResultData = {
+    [PriceBandPriceFindResultFields.COLUMN_BUY]: number;
+    [PriceBandPriceFindResultFields.COLUMN_SELL]: number;
+    [PriceBandPriceFindResultFields.COLUMN_PUBLIC]: number;
+};
+export declare type PriceBandPriceFindResultDataKeywords = {
+    [PriceBandPriceFindResultFields.COLUMN_BUY]?: DataKeywords;
+    [PriceBandPriceFindResultFields.COLUMN_SELL]?: DataKeywords;
+    [PriceBandPriceFindResultFields.COLUMN_PUBLIC]?: DataKeywords;
+};
+export declare type PriceBandPriceFindResultDataSortParameters = {
+    [PriceBandPriceFindResultFields.COLUMN_BUY]?: SortParameters;
+    [PriceBandPriceFindResultFields.COLUMN_SELL]?: SortParameters;
+    [PriceBandPriceFindResultFields.COLUMN_PUBLIC]?: SortParameters;
+};
+export declare type PriceBandPriceFindResultDataFiltersParameters = {
+    [PriceBandPriceFindResultFields.COLUMN_BUY]?: FiltersParameters;
+    [PriceBandPriceFindResultFields.COLUMN_SELL]?: FiltersParameters;
+    [PriceBandPriceFindResultFields.COLUMN_PUBLIC]?: FiltersParameters;
+};
+export declare class PriceBandPriceFindResult extends AbstractEntity<PriceBandPriceFindResultData> {
+    #private;
+    protected VALIDATION_RULES: Rules;
+    constructor(data: PriceBandPriceFindResultData);
+    get buy(): number;
+    get sell(): number;
+    get public(): number;
+    toJSON(): PriceBandPriceFindResultData;
+}

package/build/licenses/entities/offer/priceband/priceBandPriceFindResult.js

@@ -0,0 +1,59 @@
+"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 _buy, _sell, _public;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceBandPriceFindResult = exports.PriceBandPriceFindResultFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var PriceBandPriceFindResultFields;
+(function (PriceBandPriceFindResultFields) {
+    PriceBandPriceFindResultFields["COLUMN_BUY"] = "buy";
+    PriceBandPriceFindResultFields["COLUMN_SELL"] = "sell";
+    PriceBandPriceFindResultFields["COLUMN_PUBLIC"] = "public";
+})(PriceBandPriceFindResultFields = exports.PriceBandPriceFindResultFields || (exports.PriceBandPriceFindResultFields = {}));
+class PriceBandPriceFindResult extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        this.VALIDATION_RULES = {
+            [PriceBandPriceFindResultFields.COLUMN_BUY]: 'required|numeric',
+            [PriceBandPriceFindResultFields.COLUMN_SELL]: 'required|numeric',
+            [PriceBandPriceFindResultFields.COLUMN_PUBLIC]: 'required|numeric',
+        };
+        _buy.set(this, void 0);
+        _sell.set(this, void 0);
+        _public.set(this, void 0);
+        __classPrivateFieldSet(this, _buy, data[PriceBandPriceFindResultFields.COLUMN_BUY]);
+        __classPrivateFieldSet(this, _sell, data[PriceBandPriceFindResultFields.COLUMN_SELL]);
+        __classPrivateFieldSet(this, _public, data[PriceBandPriceFindResultFields.COLUMN_PUBLIC]);
+    }
+    get buy() {
+        return __classPrivateFieldGet(this, _buy);
+    }
+    get sell() {
+        return __classPrivateFieldGet(this, _sell);
+    }
+    get public() {
+        return __classPrivateFieldGet(this, _public);
+    }
+    toJSON() {
+        return {
+            [PriceBandPriceFindResultFields.COLUMN_BUY]: this.buy,
+            [PriceBandPriceFindResultFields.COLUMN_SELL]: this.sell,
+            [PriceBandPriceFindResultFields.COLUMN_PUBLIC]: this.public,
+        };
+    }
+}
+exports.PriceBandPriceFindResult = PriceBandPriceFindResult;
+_buy = new WeakMap(), _sell = new WeakMap(), _public = new WeakMap();
+//# sourceMappingURL=priceBandPriceFindResult.js.map

package/build/licenses/entities/offer/priceband/saleConstraintsFindResult.d.ts

@@ -0,0 +1,29 @@
+import { DataKeywords, FiltersParameters, SortParameters } from '../../../licensesClient';
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum SaleConstraintsFindResultFields {
+    COLUMN_MIN_QUANTITY = "minQuantity",
+    COLUMN_MAX_QUANTITY = "maxQuantity"
+}
+export declare type SaleConstraintsFindResultData = {
+    [SaleConstraintsFindResultFields.COLUMN_MIN_QUANTITY]: number | null;
+    [SaleConstraintsFindResultFields.COLUMN_MAX_QUANTITY]: number | null;
+};
+export declare type SaleConstraintsFindResultDataKeywords = {
+    [SaleConstraintsFindResultFields.COLUMN_MIN_QUANTITY]?: DataKeywords;
+    [SaleConstraintsFindResultFields.COLUMN_MAX_QUANTITY]?: DataKeywords;
+};
+export declare type SaleConstraintsFindResultDataSortParameters = {
+    [SaleConstraintsFindResultFields.COLUMN_MIN_QUANTITY]?: SortParameters;
+    [SaleConstraintsFindResultFields.COLUMN_MAX_QUANTITY]?: SortParameters;
+};
+export declare type SaleConstraintsFindResultDataFiltersParameters = {
+    [SaleConstraintsFindResultFields.COLUMN_MIN_QUANTITY]?: FiltersParameters;
+    [SaleConstraintsFindResultFields.COLUMN_MAX_QUANTITY]?: FiltersParameters;
+};
+export declare class SaleConstraintsFindResult extends AbstractEntity<SaleConstraintsFindResultData> {
+    #private;
+    constructor(data: SaleConstraintsFindResultData);
+    get minQuantity(): number | null;
+    get maxQuantity(): number | null;
+    toJSON(): SaleConstraintsFindResultData;
+}

package/build/licenses/entities/offer/priceband/saleConstraintsFindResult.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 _minQuantity, _maxQuantity;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaleConstraintsFindResult = exports.SaleConstraintsFindResultFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var SaleConstraintsFindResultFields;
+(function (SaleConstraintsFindResultFields) {
+    SaleConstraintsFindResultFields["COLUMN_MIN_QUANTITY"] = "minQuantity";
+    SaleConstraintsFindResultFields["COLUMN_MAX_QUANTITY"] = "maxQuantity";
+})(SaleConstraintsFindResultFields = exports.SaleConstraintsFindResultFields || (exports.SaleConstraintsFindResultFields = {}));
+class SaleConstraintsFindResult extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        _minQuantity.set(this, void 0);
+        _maxQuantity.set(this, void 0);
+        __classPrivateFieldSet(this, _minQuantity, data[SaleConstraintsFindResultFields.COLUMN_MIN_QUANTITY]);
+        __classPrivateFieldSet(this, _maxQuantity, data[SaleConstraintsFindResultFields.COLUMN_MAX_QUANTITY]);
+    }
+    get minQuantity() {
+        return __classPrivateFieldGet(this, _minQuantity);
+    }
+    get maxQuantity() {
+        return __classPrivateFieldGet(this, _maxQuantity);
+    }
+    toJSON() {
+        return {
+            [SaleConstraintsFindResultFields.COLUMN_MIN_QUANTITY]: this.minQuantity,
+            [SaleConstraintsFindResultFields.COLUMN_MAX_QUANTITY]: this.maxQuantity,
+        };
+    }
+}
+exports.SaleConstraintsFindResult = SaleConstraintsFindResult;
+_minQuantity = new WeakMap(), _maxQuantity = new WeakMap();
+//# sourceMappingURL=saleConstraintsFindResult.js.map

package/build/licenses/index.d.ts

@@ -1,6 +1,17 @@
 export * from './licensesClient';
-export * from './entities/license/abstractLicense';
+export * from './entities/license/activeSeatsFindResult';
+export * from './entities/license/configFindResult';
+export * from './entities/license/licenseFindResult';
+export * from './entities/license/priceFindResult';
+export * from './entities/license/warningFindResult';
+export * from './entities/offer/priceband/identifiers/arrowsphereFindResult';
+export * from './entities/offer/priceband/billingFindResult';
+export * from './entities/offer/priceband/identifiersFindResult';
+export * from './entities/offer/priceband/priceBandActionFlagsFindResult';
+export * from './entities/offer/priceband/priceBandPriceFindResult';
+export * from './entities/offer/priceband/saleConstraintsFindResult';
+export * from './entities/offer/actionFlagsFindResult';
+export * from './entities/offer/offerFindResult';
+export * from './entities/offer/priceBandFindResult';
 export * from './entities/filterFindResult';
 export * from './entities/findResult';
-export * from './entities/license/licenseFindResult';
-export * from './entities/offer/licenseOfferFindResult';

package/build/licenses/index.js

@@ -11,9 +11,20 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./licensesClient"), exports);
-__exportStar(require("./entities/license/abstractLicense"), exports);
+__exportStar(require("./entities/license/activeSeatsFindResult"), exports);
+__exportStar(require("./entities/license/configFindResult"), exports);
+__exportStar(require("./entities/license/licenseFindResult"), exports);
+__exportStar(require("./entities/license/priceFindResult"), exports);
+__exportStar(require("./entities/license/warningFindResult"), exports);
+__exportStar(require("./entities/offer/priceband/identifiers/arrowsphereFindResult"), exports);
+__exportStar(require("./entities/offer/priceband/billingFindResult"), exports);
+__exportStar(require("./entities/offer/priceband/identifiersFindResult"), exports);
+__exportStar(require("./entities/offer/priceband/priceBandActionFlagsFindResult"), exports);
+__exportStar(require("./entities/offer/priceband/priceBandPriceFindResult"), exports);
+__exportStar(require("./entities/offer/priceband/saleConstraintsFindResult"), exports);
+__exportStar(require("./entities/offer/actionFlagsFindResult"), exports);
+__exportStar(require("./entities/offer/offerFindResult"), exports);
+__exportStar(require("./entities/offer/priceBandFindResult"), exports);
 __exportStar(require("./entities/filterFindResult"), exports);
 __exportStar(require("./entities/findResult"), exports);
-__exportStar(require("./entities/license/licenseFindResult"), exports);
-__exportStar(require("./entities/offer/licenseOfferFindResult"), exports);
 //# sourceMappingURL=index.js.map

package/build/licenses/licensesClient.d.ts

@@ -2,8 +2,15 @@
  * Class LicensesClient
  */
 import { AbstractClient, Parameters } from '../abstractClient';
-import { FindData, FindResult } from './entities/findResult';
-import { LicenseFields } from './entities/license/abstractLicense';
+import { FindConfig, FindData, FindResult } from './entities/findResult';
+import { ConfigFindResult, ConfigFindResultData, ConfigFindResultDataKeywords, ConfigFindResultDataSortParameters } from './entities/license/configFindResult';
+import { LicenceFindDataFiltersParameters, LicenceFindDataKeywords, LicenceFindDataSortParameters } from './entities/license/licenseFindResult';
+import { ActiveSeatsFindResultDataKeywords, ActiveSeatsFindResultDataSortParameters } from './entities/license/activeSeatsFindResult';
+import { WarningFindResultDataKeywords, WarningFindResultDataSortParameters } from './entities/license/warningFindResult';
+import { PriceFindResultDataKeywords, PriceFindResutDataSortParameters } from './entities/license/priceFindResult';
+import { OfferFindResultDataFiltersParameters, OfferFindResultDataKeywords, OfferFindResultDataSortParameters } from './entities/offer/offerFindResult';
+import { ActionFlagsFindResultDataKeywords, ActionFlagsFindResultDataSortParameters } from './entities/offer/actionFlagsFindResult';
+import { PriceBandFindResultDataKeywords, PriceBandFindResultDataSortParameters } from './entities/offer/priceBandFindResult';
 /**
  * Parameters passable to the request for refining search.
  */
@@ -60,7 +67,7 @@ export declare enum LicenseFindParameters {
 /**
  * List of keywords to search with.
  */
-export declare type LicenseDataKeywords = {
+export declare type DataKeywords = {
     [LicenseFindParameters.KEYWORDS_OPERATOR]: LicenseFindParameters.OPERATOR_AND | LicenseFindParameters.OPERATOR_OR | LicenseFindParameters.OPERATOR_BETWEEN;
     [LicenseFindParameters.KEYWORDS_VALUES]: string[];
 };
@@ -68,19 +75,43 @@ export declare type LicenseDataKeywords = {
  * Keywords parameters to pass to the request
  */
 export declare type LicenseKeywordsParameters = {
-    [field in LicenseFields]?: LicenseDataKeywords;
+    license?: LicenceFindDataKeywords;
+    offer?: OfferFindResultDataKeywords;
+};
+export declare type LicenseRawKeywordsParametersLicence = {
+    [field: string]: DataKeywords | ActiveSeatsFindResultDataKeywords | ConfigFindResultDataKeywords | WarningFindResultDataKeywords | PriceFindResultDataKeywords | undefined;
+};
+export declare type LicenseRawKeywordsParametersOffer = {
+    [field: string]: DataKeywords | ActionFlagsFindResultDataKeywords | PriceBandFindResultDataKeywords | undefined;
+};
+export declare type SortParameters = {
+    [LicenseFindParameters.DATA_SORT]: LicenseFindParameters.SORT_ASCENDING | LicenseFindParameters.SORT_DESCENDING;
 };
 /**
  * Sort parameters to pass to the request
  */
 export declare type LicenseSortParameters = {
-    [field in LicenseFields]?: LicenseFindParameters.SORT_ASCENDING | LicenseFindParameters.SORT_DESCENDING;
+    license?: LicenceFindDataSortParameters;
+    offer?: OfferFindResultDataSortParameters;
+};
+export declare type LicenseRawSortParametersLicense = {
+    [field: string]: SortParameters | ActiveSeatsFindResultDataSortParameters | ConfigFindResultDataSortParameters | WarningFindResultDataSortParameters | PriceFindResutDataSortParameters | undefined;
+};
+export declare type LicenseRawSortParametersOffer = {
+    [field: string]: SortParameters | ActionFlagsFindResultDataSortParameters | PriceBandFindResultDataSortParameters | undefined;
+};
+export declare type FiltersParameters = {
+    [LicenseFindParameters.DATA_FILTERS]: unknown;
 };
 /**
  * Filter parameters to pass to the request.
  */
 export declare type LicenseFiltersParameters = {
-    [field in LicenseFields]?: unknown;
+    license?: LicenceFindDataFiltersParameters;
+    offer?: OfferFindResultDataFiltersParameters;
+};
+export declare type LicenseRawFiltersParameters = {
+    [field: string]: unknown;
 };
 /**
  * Payload to pass the find request. Contains keyword(s), sort options, column filters and highlight option.
@@ -92,6 +123,19 @@ export declare type LicenseFindPayload = {
     [LicenseFindParameters.DATA_SORT]?: LicenseSortParameters;
     [LicenseFindParameters.DATA_HIGHLIGHT]?: boolean;
 };
+export declare type LicenseFindRawPayload = {
+    [LicenseFindParameters.DATA_KEYWORD]?: string;
+    [LicenseFindParameters.DATA_KEYWORDS]?: {
+        license?: LicenseRawKeywordsParametersLicence;
+        offer?: LicenseRawKeywordsParametersOffer;
+    };
+    [LicenseFindParameters.DATA_FILTERS]?: LicenseRawFiltersParameters;
+    [LicenseFindParameters.DATA_SORT]?: {
+        license?: LicenseRawSortParametersLicense;
+        offer?: LicenseRawSortParametersOffer;
+    };
+    [LicenseFindParameters.DATA_HIGHLIGHT]?: boolean;
+};
 export declare class LicensesClient extends AbstractClient {
     /**
      * The base path of the Licenses API
@@ -105,6 +149,10 @@ export declare class LicensesClient extends AbstractClient {
      * The path of the Find endpoint
      */
     private FIND_PATH;
+    /**
+     * The path of the Configs endpoint
+     */
+    private CONFIGS_PATH;
     /**
      * Returns the raw result from the find endpoint call
      *
@@ -113,7 +161,7 @@ export declare class LicensesClient extends AbstractClient {
      *
      * @returns Promise\<{@link FindData}\>
      */
-    findRaw(postData?: LicenseFindPayload, parameters?: Parameters): Promise<FindData>;
+    findRaw(postData?: LicenseFindRawPayload, parameters?: Parameters): Promise<FindData>;
     /**
      * Searches for licenses and returns a FindResult to manipulate the results.
      *
@@ -126,4 +174,8 @@ export declare class LicensesClient extends AbstractClient {
      *
      */
     find(postData?: LicenseFindPayload, perPage?: number, page?: number, parameters?: Parameters): Promise<FindResult>;
+    getConfigsRaw(reference: string): Promise<FindConfig>;
+    getConfigs(reference: string): AsyncGenerator<ConfigFindResultData>;
+    updateConfigRaw(reference: string, config: ConfigFindResult): Promise<ConfigFindResultData>;
+    updateConfig(reference: string, config: ConfigFindResult): Promise<ConfigFindResult>;
 }

package/build/licenses/licensesClient.js

@@ -6,6 +6,7 @@ exports.LicensesClient = exports.LicenseFindParameters = void 0;
  */
 const abstractClient_1 = require("../abstractClient");
 const findResult_1 = require("./entities/findResult");
+const configFindResult_1 = require("./entities/license/configFindResult");
 /**
  * Parameters passable to the request for refining search.
  */
@@ -75,6 +76,10 @@ class LicensesClient extends abstractClient_1.AbstractClient {
          * The path of the Find endpoint
          */
         this.FIND_PATH = 'v2/find';
+        /**
+         * The path of the Configs endpoint
+         */
+        this.CONFIGS_PATH = '/configs';
     }
     /**
      * Returns the raw result from the find endpoint call
@@ -100,10 +105,77 @@ class LicensesClient extends abstractClient_1.AbstractClient {
      *
      */
     async find(postData = {}, perPage = 100, page = 1, parameters = {}) {
+        var _a, _b, _c, _d, _e, _f;
         this.setPerPage(perPage);
         this.setPage(page);
-        const response = await this.findRaw(postData, parameters);
-        return new findResult_1.FindResult(response, this, postData, parameters);
+        const rawLicensePayload = {
+            keyword: postData.keyword,
+            highlight: postData.highlight,
+        };
+        if (postData.keywords) {
+            // Flatten with prefix for each type of keyword (license and offer)
+            rawLicensePayload.keywords = {
+                ...Object.entries((_a = postData.keywords.license) !== null && _a !== void 0 ? _a : {}).reduce((acc, [keyword, value]) => {
+                    acc[`license.${keyword}`] = value;
+                    return acc;
+                }, {}),
+                ...Object.entries((_b = postData.keywords.offer) !== null && _b !== void 0 ? _b : {}).reduce((acc, [keyword, value]) => {
+                    acc[`offer.${keyword}`] = value;
+                    return acc;
+                }, {}),
+            };
+        }
+        if (postData.filters) {
+            // Flatten with prefix for each type of filter (license and offer)
+            rawLicensePayload.filters = {
+                ...Object.entries((_c = postData.filters.license) !== null && _c !== void 0 ? _c : {}).reduce((acc, [filter, value]) => {
+                    acc[`license.${filter}`] = value;
+                    return acc;
+                }, {}),
+                ...Object.entries((_d = postData.filters.offer) !== null && _d !== void 0 ? _d : {}).reduce((acc, [filter, value]) => {
+                    acc[`offer.${filter}`] = value;
+                    return acc;
+                }, {}),
+            };
+        }
+        if (postData.sort) {
+            // Flatten with prefix for each type of sort keys (license and offer)
+            rawLicensePayload.sort = {
+                ...Object.entries((_e = postData.sort.license) !== null && _e !== void 0 ? _e : {}).reduce((acc, [sort, value]) => {
+                    acc[`license.${sort}`] = value;
+                    return acc;
+                }, {}),
+                ...Object.entries((_f = postData.sort.offer) !== null && _f !== void 0 ? _f : {}).reduce((acc, [sort, value]) => {
+                    acc[`offer.${sort}`] = value;
+                    return acc;
+                }, {}),
+            };
+        }
+        const response = await this.findRaw(rawLicensePayload, parameters);
+        return new findResult_1.FindResult(response, this, rawLicensePayload, parameters);
+    }
+    getConfigsRaw(reference) {
+        this.path = reference + this.CONFIGS_PATH;
+        return this.get();
+    }
+    async *getConfigs(reference) {
+        const rawResponse = await this.getConfigsRaw(reference);
+        for (const response of rawResponse.data) {
+            yield new configFindResult_1.ConfigFindResult(response).toJSON();
+        }
+    }
+    async updateConfigRaw(reference, config) {
+        this.path = reference + this.CONFIGS_PATH;
+        const postData = {
+            [configFindResult_1.ConfigFindResultFields.COLUMN_NAME]: config.name,
+            [configFindResult_1.ConfigFindResultFields.COLUMN_SCOPE]: config.scope,
+            [configFindResult_1.ConfigFindResultFields.COLUMN_STATE]: config.state,
+        };
+        return await this.post(postData);
+    }
+    async updateConfig(reference, config) {
+        const rawResponse = await this.updateConfigRaw(reference, config);
+        return new configFindResult_1.ConfigFindResult(rawResponse);
     }
 }
 exports.LicensesClient = LicensesClient;

package/build/publicApiClient.js

@@ -17,7 +17,9 @@ class PublicApiClient extends abstractClient_1.AbstractClient {
      * @returns {@link WhoAmIClient}
      */
     getWhoamiClient() {
-        return new general_1.WhoAmIClient(this.client).setUrl(this.url).setApiKey(this.apiKey);
+        return new general_1.WhoAmIClient(this.client)
+            .setUrl(this.url)
+            .setApiKey(this.apiKey);
     }
     /**
      * Creates a new {@link LicensesClient} instance and returns it

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/ArrowSphere/nodejs-api-client.git"
   },
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Node.js client for ArrowSphere's public API",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -14,7 +14,7 @@
     "doc": "typedoc ./src/index.ts ./src/**/index.ts",
     "lint": "eslint ./{src,tests}/**/*.ts && prettier --list-different ./{src,tests}/**/*.ts",
     "lint:fix": "eslint ./{src,tests}/**/*.ts --fix && prettier --write ./{src,tests}/**/*.ts",
-    "prepublishOnly": "npm run clean && npm run build",
+    "prepare": "npm run clean && npm run build",
     "test": "mocha -r ts-node/register \"tests/**/*.ts\"",
     "test:watch": "mocha --watch -r ts-node/register \"tests/**/*.ts\"",
     "test:coverage": "nyc --check-coverage npm run test",