@arrowsphere/api-client 1.0.3 → 2.1.1

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,24 @@
 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 '../licenses/entities/getLicense/actionMessagesGetResult';
+export * from '../licenses/entities/getLicense/actionsGetResult';
+export * from '../licenses/entities/getLicense/buySellFindResult';
+export * from '../licenses/entities/getLicense/licenseGetResult';
+export * from '../licenses/entities/getLicense/licensePriceGetResult';
+export * from '../licenses/entities/getLicense/orderGetResult';
 export * from './entities/filterFindResult';
 export * from './entities/findResult';
-export * from './entities/license/licenseFindResult';
-export * from './entities/offer/licenseOfferFindResult';
+export * from './entities/getResult';

package/build/licenses/index.js

@@ -11,9 +11,27 @@ 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("../licenses/entities/getLicense/actionMessagesGetResult"), exports);
+__exportStar(require("../licenses/entities/getLicense/actionsGetResult"), exports);
+__exportStar(require("../licenses/entities/getLicense/buySellFindResult"), exports);
+__exportStar(require("../licenses/entities/getLicense/licenseGetResult"), exports);
+__exportStar(require("../licenses/entities/getLicense/licensePriceGetResult"), exports);
+__exportStar(require("../licenses/entities/getLicense/orderGetResult"), exports);
 __exportStar(require("./entities/filterFindResult"), exports);
 __exportStar(require("./entities/findResult"), exports);
-__exportStar(require("./entities/license/licenseFindResult"), exports);
-__exportStar(require("./entities/offer/licenseOfferFindResult"), exports);
+__exportStar(require("./entities/getResult"), exports);
 //# sourceMappingURL=index.js.map

package/build/licenses/licensesClient.d.ts

@@ -2,9 +2,16 @@
  * Class LicensesClient
  */
 import { AbstractClient, Parameters } from '../abstractClient';
-import { FindData, FindResult } from './entities/findResult';
-import { LicenseFields } from './entities/license/abstractLicense';
-import { LicenseOfferFields } from './entities/offer/licenseOfferFindResult';
+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';
+import { GetData, LicenseGet } from './entities/getResult';
 /**
  * Parameters passable to the request for refining search.
  */
@@ -56,12 +63,52 @@ export declare enum LicenseFindParameters {
     /**
      * Use this operator to search for all keywords with values in the range specified (for date ranges)
      */
-    OPERATOR_BETWEEN = "BETWEEN"
+    OPERATOR_BETWEEN = "BETWEEN",
+    /**
+     * Use this operator to search with a compare field Equal
+     */
+    OPERATOR_EQ = "EQ",
+    /**
+     * Use this operator to search with a compare field Not Equal
+     */
+    OPERATOR_NEQ = "NEQ",
+    /**
+     * Use this operator to search with a compare field Greater Than
+     */
+    OPERATOR_GT = "GT",
+    /**
+     * Use this operator to search with a compare field Greater Than or Equal
+     */
+    OPERATOR_GTE = "GTE",
+    /**
+     * Use this operator to search with a compare field Lower Than
+     */
+    OPERATOR_LT = "LT",
+    /**
+     * Use this operator to search with a compare field Lower Than or Equal
+     */
+    OPERATOR_LTE = "LTE",
+    /**
+     * Use this filter to compare 2 value with other filter like FILTERS_GTE / FILTERS_LT / FILTERS_LTE
+     */
+    FILTERS_GT = "gt",
+    /**
+     * Use this filter to compare 2 value with other filter like FILTERS_GT / FILTERS_LT / FILTERS_LTE
+     */
+    FILTERS_GTE = "gte",
+    /**
+     * Use this filter to compare 2 value with other filter like FILTERS_GT / FILTERS_GTE / FILTERS_LTE
+     */
+    FILTERS_LT = "lt",
+    /**
+     * Use this filter to compare 2 value with other filter like FILTERS_GT / FILTERS_GTE / FILTERS_LT
+     */
+    FILTERS_LTE = "lte"
 }
 /**
  * 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[];
 };
@@ -69,40 +116,42 @@ export declare type LicenseDataKeywords = {
  * Keywords parameters to pass to the request
  */
 export declare type LicenseKeywordsParameters = {
-    license?: {
-        [field in LicenseFields]?: LicenseDataKeywords;
-    };
-    offer?: {
-        [field in LicenseOfferFields]?: LicenseDataKeywords;
-    };
+    license?: LicenceFindDataKeywords;
+    offer?: OfferFindResultDataKeywords;
+};
+export declare type LicenseRawKeywordsParametersLicence = {
+    [field: string]: DataKeywords | ActiveSeatsFindResultDataKeywords | ConfigFindResultDataKeywords | WarningFindResultDataKeywords | PriceFindResultDataKeywords | undefined;
 };
-export declare type LicenseRawKeywordsParameters = {
-    [field: string]: LicenseDataKeywords | undefined;
+export declare type LicenseRawKeywordsParametersOffer = {
+    [field: string]: DataKeywords | ActionFlagsFindResultDataKeywords | PriceBandFindResultDataKeywords | undefined;
 };
+export declare type SortParameters = LicenseFindParameters.SORT_ASCENDING | LicenseFindParameters.SORT_DESCENDING;
 /**
  * Sort parameters to pass to the request
  */
 export declare type LicenseSortParameters = {
-    license?: {
-        [field in LicenseFields]?: LicenseFindParameters.SORT_ASCENDING | LicenseFindParameters.SORT_DESCENDING;
-    };
-    offer?: {
-        [field in LicenseOfferFields]?: LicenseFindParameters.SORT_ASCENDING | LicenseFindParameters.SORT_DESCENDING;
-    };
+    license?: LicenceFindDataSortParameters;
+    offer?: OfferFindResultDataSortParameters;
 };
-export declare type LicenseRawSortParameters = {
-    [field: string]: string | undefined;
+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 FiltersCompareValue = {
+    [LicenseFindParameters.FILTERS_GT]?: string | number;
+    [LicenseFindParameters.FILTERS_GTE]?: string | number;
+    [LicenseFindParameters.FILTERS_LT]?: string | number;
+    [LicenseFindParameters.FILTERS_LTE]?: string | number;
+};
+export declare type FiltersParameters = string | string[] | number | number[] | boolean | FiltersCompareValue;
 /**
  * Filter parameters to pass to the request.
  */
 export declare type LicenseFiltersParameters = {
-    license?: {
-        [field in LicenseFields]?: unknown;
-    };
-    offer?: {
-        [field in LicenseOfferFields]?: unknown;
-    };
+    license?: LicenceFindDataFiltersParameters;
+    offer?: OfferFindResultDataFiltersParameters;
 };
 export declare type LicenseRawFiltersParameters = {
     [field: string]: unknown;
@@ -119,9 +168,15 @@ export declare type LicenseFindPayload = {
 };
 export declare type LicenseFindRawPayload = {
     [LicenseFindParameters.DATA_KEYWORD]?: string;
-    [LicenseFindParameters.DATA_KEYWORDS]?: LicenseRawKeywordsParameters;
+    [LicenseFindParameters.DATA_KEYWORDS]?: {
+        license?: LicenseRawKeywordsParametersLicence;
+        offer?: LicenseRawKeywordsParametersOffer;
+    };
     [LicenseFindParameters.DATA_FILTERS]?: LicenseRawFiltersParameters;
-    [LicenseFindParameters.DATA_SORT]?: LicenseRawSortParameters;
+    [LicenseFindParameters.DATA_SORT]?: {
+        license?: LicenseRawSortParametersLicense;
+        offer?: LicenseRawSortParametersOffer;
+    };
     [LicenseFindParameters.DATA_HIGHLIGHT]?: boolean;
 };
 export declare class LicensesClient extends AbstractClient {
@@ -137,6 +192,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
      *
@@ -158,4 +217,9 @@ 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>;
+    getLicense(licenseReference: string, parameters?: Parameters): Promise<GetData<LicenseGet>>;
 }