@arrowsphere/api-client 1.0.1 → 2.0.1

package/build/licenses/entities/offer/actionFlagsFindResult.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 _isAutoRenew, _isManualProvisioning, _renewalSku;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionFlagsFindResult = exports.ActionFlagsFindResultFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+var ActionFlagsFindResultFields;
+(function (ActionFlagsFindResultFields) {
+    ActionFlagsFindResultFields["COLUMN_IS_AUTO_RENEW"] = "isAutoRenew";
+    ActionFlagsFindResultFields["COLUMN_MANUAL_PROVISIONING"] = "isManualProvisioning";
+    ActionFlagsFindResultFields["COLUMN_RENEWAL_SKU"] = "renewalSku";
+})(ActionFlagsFindResultFields = exports.ActionFlagsFindResultFields || (exports.ActionFlagsFindResultFields = {}));
+class ActionFlagsFindResult extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        this.VALIDATION_RULES = {
+            [ActionFlagsFindResultFields.COLUMN_IS_AUTO_RENEW]: 'required|boolean',
+            [ActionFlagsFindResultFields.COLUMN_MANUAL_PROVISIONING]: 'required|boolean',
+            [ActionFlagsFindResultFields.COLUMN_RENEWAL_SKU]: 'boolean',
+        };
+        _isAutoRenew.set(this, void 0);
+        _isManualProvisioning.set(this, void 0);
+        _renewalSku.set(this, void 0);
+        __classPrivateFieldSet(this, _isAutoRenew, data[ActionFlagsFindResultFields.COLUMN_IS_AUTO_RENEW]);
+        __classPrivateFieldSet(this, _isManualProvisioning, data[ActionFlagsFindResultFields.COLUMN_MANUAL_PROVISIONING]);
+        __classPrivateFieldSet(this, _renewalSku, data[ActionFlagsFindResultFields.COLUMN_RENEWAL_SKU]);
+    }
+    isAutoRenew() {
+        return __classPrivateFieldGet(this, _isAutoRenew);
+    }
+    isManualProvisioning() {
+        return __classPrivateFieldGet(this, _isManualProvisioning);
+    }
+    renewalSku() {
+        return __classPrivateFieldGet(this, _renewalSku);
+    }
+    toJSON() {
+        return {
+            [ActionFlagsFindResultFields.COLUMN_IS_AUTO_RENEW]: this.isAutoRenew(),
+            [ActionFlagsFindResultFields.COLUMN_MANUAL_PROVISIONING]: this.isManualProvisioning(),
+            [ActionFlagsFindResultFields.COLUMN_RENEWAL_SKU]: this.renewalSku(),
+        };
+    }
+}
+exports.ActionFlagsFindResult = ActionFlagsFindResult;
+_isAutoRenew = new WeakMap(), _isManualProvisioning = new WeakMap(), _renewalSku = new WeakMap();
+//# sourceMappingURL=actionFlagsFindResult.js.map

package/build/licenses/entities/offer/offerFindResult.d.ts

@@ -0,0 +1,63 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { Rules } from 'validatorjs';
+import { DataKeywords, FiltersParameters, SortParameters } from '../../licensesClient';
+import { ActionFlagsFindResult, ActionFlagsFindResultData, ActionFlagsFindResultDataFiltersParameters, ActionFlagsFindResultDataKeywords, ActionFlagsFindResultDataSortParameters } from './actionFlagsFindResult';
+import { PriceBandFindResult, PriceBandFindResultData, PriceBandFindResultDataFiltersParameters, PriceBandFindResultDataKeywords, PriceBandFindResultDataSortParameters } from './priceBandFindResult';
+export declare enum OfferFindResultFields {
+    COLUMN_ACTION_FLAGS = "actionFlags",
+    COLUMN_CLASSIFICATION = "classification",
+    COLUMN_IS_ENABLED = "isEnabled",
+    COLUMN_LAST_UPDATE = "lastUpdate",
+    COLUMN_NAME = "name",
+    COLUMN_PRICE_BAND = "priceBand",
+    COLUMN_ARROW_SUB_CATEGORIES = "arrowSubCategories"
+}
+export declare type OfferFindResultData = {
+    [OfferFindResultFields.COLUMN_ACTION_FLAGS]: ActionFlagsFindResultData;
+    [OfferFindResultFields.COLUMN_CLASSIFICATION]: string;
+    [OfferFindResultFields.COLUMN_IS_ENABLED]: boolean;
+    [OfferFindResultFields.COLUMN_LAST_UPDATE]: string;
+    [OfferFindResultFields.COLUMN_NAME]: string;
+    [OfferFindResultFields.COLUMN_PRICE_BAND]: PriceBandFindResultData;
+    [OfferFindResultFields.COLUMN_ARROW_SUB_CATEGORIES]: Array<string> | null;
+};
+export declare type OfferFindResultDataKeywords = {
+    [OfferFindResultFields.COLUMN_ACTION_FLAGS]?: ActionFlagsFindResultDataKeywords;
+    [OfferFindResultFields.COLUMN_CLASSIFICATION]?: DataKeywords;
+    [OfferFindResultFields.COLUMN_IS_ENABLED]?: DataKeywords;
+    [OfferFindResultFields.COLUMN_LAST_UPDATE]?: DataKeywords;
+    [OfferFindResultFields.COLUMN_NAME]?: DataKeywords;
+    [OfferFindResultFields.COLUMN_PRICE_BAND]?: PriceBandFindResultDataKeywords;
+    [OfferFindResultFields.COLUMN_ARROW_SUB_CATEGORIES]?: DataKeywords;
+};
+export declare type OfferFindResultDataSortParameters = {
+    [OfferFindResultFields.COLUMN_ACTION_FLAGS]?: ActionFlagsFindResultDataSortParameters;
+    [OfferFindResultFields.COLUMN_CLASSIFICATION]?: SortParameters;
+    [OfferFindResultFields.COLUMN_IS_ENABLED]?: SortParameters;
+    [OfferFindResultFields.COLUMN_LAST_UPDATE]?: SortParameters;
+    [OfferFindResultFields.COLUMN_NAME]?: SortParameters;
+    [OfferFindResultFields.COLUMN_PRICE_BAND]?: PriceBandFindResultDataSortParameters;
+    [OfferFindResultFields.COLUMN_ARROW_SUB_CATEGORIES]?: SortParameters;
+};
+export declare type OfferFindResultDataFiltersParameters = {
+    [OfferFindResultFields.COLUMN_ACTION_FLAGS]?: ActionFlagsFindResultDataFiltersParameters;
+    [OfferFindResultFields.COLUMN_CLASSIFICATION]?: FiltersParameters;
+    [OfferFindResultFields.COLUMN_IS_ENABLED]?: FiltersParameters;
+    [OfferFindResultFields.COLUMN_LAST_UPDATE]?: FiltersParameters;
+    [OfferFindResultFields.COLUMN_NAME]?: FiltersParameters;
+    [OfferFindResultFields.COLUMN_PRICE_BAND]?: PriceBandFindResultDataFiltersParameters;
+    [OfferFindResultFields.COLUMN_ARROW_SUB_CATEGORIES]?: FiltersParameters;
+};
+export declare class OfferFindResult extends AbstractEntity<OfferFindResultData> {
+    #private;
+    protected VALIDATION_RULES: Rules;
+    constructor(data: OfferFindResultData);
+    get actionFlags(): ActionFlagsFindResult;
+    get classification(): string;
+    get isEnabled(): boolean;
+    get lastUpdate(): string;
+    get name(): string;
+    get priceBand(): PriceBandFindResult;
+    get arrowSubCategories(): Array<string> | null;
+    toJSON(): OfferFindResultData;
+}

package/build/licenses/entities/offer/offerFindResult.js

@@ -0,0 +1,109 @@
+"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 _actionFlags, _classification, _isEnabled, _lastUpdate, _name, _priceBand, _arrowSubCategories;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfferFindResult = exports.OfferFindResultFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const actionFlagsFindResult_1 = require("./actionFlagsFindResult");
+const priceBandFindResult_1 = require("./priceBandFindResult");
+var OfferFindResultFields;
+(function (OfferFindResultFields) {
+    OfferFindResultFields["COLUMN_ACTION_FLAGS"] = "actionFlags";
+    OfferFindResultFields["COLUMN_CLASSIFICATION"] = "classification";
+    OfferFindResultFields["COLUMN_IS_ENABLED"] = "isEnabled";
+    OfferFindResultFields["COLUMN_LAST_UPDATE"] = "lastUpdate";
+    OfferFindResultFields["COLUMN_NAME"] = "name";
+    OfferFindResultFields["COLUMN_PRICE_BAND"] = "priceBand";
+    OfferFindResultFields["COLUMN_ARROW_SUB_CATEGORIES"] = "arrowSubCategories";
+})(OfferFindResultFields = exports.OfferFindResultFields || (exports.OfferFindResultFields = {}));
+class OfferFindResult extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        this.VALIDATION_RULES = {
+            [OfferFindResultFields.COLUMN_ACTION_FLAGS]: 'required|array',
+            [OfferFindResultFields.COLUMN_CLASSIFICATION]: 'required|string',
+            [OfferFindResultFields.COLUMN_IS_ENABLED]: 'required|boolean',
+            [OfferFindResultFields.COLUMN_LAST_UPDATE]: 'required|string',
+            [OfferFindResultFields.COLUMN_NAME]: 'required|string',
+            [OfferFindResultFields.COLUMN_PRICE_BAND]: 'required|array',
+            [OfferFindResultFields.COLUMN_ARROW_SUB_CATEGORIES]: 'required',
+        };
+        _actionFlags.set(this, void 0);
+        _classification.set(this, void 0);
+        _isEnabled.set(this, void 0);
+        _lastUpdate.set(this, void 0);
+        _name.set(this, void 0);
+        _priceBand.set(this, void 0);
+        _arrowSubCategories.set(this, void 0);
+        const actionFlags = {
+            [actionFlagsFindResult_1.ActionFlagsFindResultFields.COLUMN_IS_AUTO_RENEW]: data[OfferFindResultFields.COLUMN_ACTION_FLAGS][actionFlagsFindResult_1.ActionFlagsFindResultFields.COLUMN_IS_AUTO_RENEW],
+            [actionFlagsFindResult_1.ActionFlagsFindResultFields.COLUMN_MANUAL_PROVISIONING]: data[OfferFindResultFields.COLUMN_ACTION_FLAGS][actionFlagsFindResult_1.ActionFlagsFindResultFields.COLUMN_MANUAL_PROVISIONING],
+            [actionFlagsFindResult_1.ActionFlagsFindResultFields.COLUMN_RENEWAL_SKU]: data[OfferFindResultFields.COLUMN_ACTION_FLAGS][actionFlagsFindResult_1.ActionFlagsFindResultFields.COLUMN_RENEWAL_SKU],
+        };
+        __classPrivateFieldSet(this, _actionFlags, new actionFlagsFindResult_1.ActionFlagsFindResult(actionFlags));
+        __classPrivateFieldSet(this, _classification, data[OfferFindResultFields.COLUMN_CLASSIFICATION]);
+        __classPrivateFieldSet(this, _isEnabled, data[OfferFindResultFields.COLUMN_IS_ENABLED]);
+        __classPrivateFieldSet(this, _lastUpdate, data[OfferFindResultFields.COLUMN_LAST_UPDATE]);
+        __classPrivateFieldSet(this, _name, data[OfferFindResultFields.COLUMN_NAME]);
+        const priceBand = {
+            [priceBandFindResult_1.PriceBandFindResultFields.COLUMN_ACTION_FLAGS]: data[OfferFindResultFields.COLUMN_PRICE_BAND][priceBandFindResult_1.PriceBandFindResultFields.COLUMN_ACTION_FLAGS],
+            [priceBandFindResult_1.PriceBandFindResultFields.COLUMN_BILLING]: data[OfferFindResultFields.COLUMN_PRICE_BAND][priceBandFindResult_1.PriceBandFindResultFields.COLUMN_BILLING],
+            [priceBandFindResult_1.PriceBandFindResultFields.COLUMN_CURRENCY]: data[OfferFindResultFields.COLUMN_PRICE_BAND][priceBandFindResult_1.PriceBandFindResultFields.COLUMN_CURRENCY],
+            [priceBandFindResult_1.PriceBandFindResultFields.COLUMN_IS_ENABLED]: data[OfferFindResultFields.COLUMN_PRICE_BAND][priceBandFindResult_1.PriceBandFindResultFields.COLUMN_IS_ENABLED],
+            [priceBandFindResult_1.PriceBandFindResultFields.COLUMN_MARKETPLACE]: data[OfferFindResultFields.COLUMN_PRICE_BAND][priceBandFindResult_1.PriceBandFindResultFields.COLUMN_MARKETPLACE],
+            [priceBandFindResult_1.PriceBandFindResultFields.COLUMN_PRICES]: data[OfferFindResultFields.COLUMN_PRICE_BAND][priceBandFindResult_1.PriceBandFindResultFields.COLUMN_PRICES],
+            [priceBandFindResult_1.PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS]: data[OfferFindResultFields.COLUMN_PRICE_BAND][priceBandFindResult_1.PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS],
+            [priceBandFindResult_1.PriceBandFindResultFields.COLUMN_IDENTIFIERS]: data[OfferFindResultFields.COLUMN_PRICE_BAND][priceBandFindResult_1.PriceBandFindResultFields.COLUMN_IDENTIFIERS],
+        };
+        __classPrivateFieldSet(this, _priceBand, new priceBandFindResult_1.PriceBandFindResult(priceBand));
+        __classPrivateFieldSet(this, _arrowSubCategories, data[OfferFindResultFields.COLUMN_ARROW_SUB_CATEGORIES]);
+    }
+    get actionFlags() {
+        return __classPrivateFieldGet(this, _actionFlags);
+    }
+    get classification() {
+        return __classPrivateFieldGet(this, _classification);
+    }
+    get isEnabled() {
+        return __classPrivateFieldGet(this, _isEnabled);
+    }
+    get lastUpdate() {
+        return __classPrivateFieldGet(this, _lastUpdate);
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _name);
+    }
+    get priceBand() {
+        return __classPrivateFieldGet(this, _priceBand);
+    }
+    get arrowSubCategories() {
+        return __classPrivateFieldGet(this, _arrowSubCategories);
+    }
+    toJSON() {
+        return {
+            [OfferFindResultFields.COLUMN_ACTION_FLAGS]: this.actionFlags.toJSON(),
+            [OfferFindResultFields.COLUMN_CLASSIFICATION]: this.classification,
+            [OfferFindResultFields.COLUMN_IS_ENABLED]: this.isEnabled,
+            [OfferFindResultFields.COLUMN_LAST_UPDATE]: this.lastUpdate,
+            [OfferFindResultFields.COLUMN_NAME]: this.name,
+            [OfferFindResultFields.COLUMN_PRICE_BAND]: this.priceBand.toJSON(),
+            [OfferFindResultFields.COLUMN_ARROW_SUB_CATEGORIES]: this
+                .arrowSubCategories,
+        };
+    }
+}
+exports.OfferFindResult = OfferFindResult;
+_actionFlags = new WeakMap(), _classification = new WeakMap(), _isEnabled = new WeakMap(), _lastUpdate = new WeakMap(), _name = new WeakMap(), _priceBand = new WeakMap(), _arrowSubCategories = new WeakMap();
+//# sourceMappingURL=offerFindResult.js.map

package/build/licenses/entities/offer/priceBandFindResult.d.ts

@@ -0,0 +1,72 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { Rules } from 'validatorjs';
+import { DataKeywords, FiltersParameters, SortParameters } from '../../licensesClient';
+import { PriceBandActionFlagsFindResultDataKeywords, PriceBandActionFlagsFindResultData, PriceBandActionFlagsDataFindResultSortParameters, PriceBandActionFlagsFindResultDataFiltersParameters, PriceBandActionFlagsFindResult } from './priceband/priceBandActionFlagsFindResult';
+import { BillingFindResult, BillingFindResultData, BillingFindResultDataFiltersParameters, BillingFindResultDataKeywords, BillingFindResultDataSortParameters } from './priceband/billingFindResult';
+import { PriceBandPriceFindResult, PriceBandPriceFindResultData, PriceBandPriceFindResultDataFiltersParameters, PriceBandPriceFindResultDataKeywords, PriceBandPriceFindResultDataSortParameters } from './priceband/priceBandPriceFindResult';
+import { SaleConstraintsFindResult, SaleConstraintsFindResultData, SaleConstraintsFindResultDataFiltersParameters, SaleConstraintsFindResultDataKeywords, SaleConstraintsFindResultDataSortParameters } from './priceband/saleConstraintsFindResult';
+import { IdentifiersFindResult, IdentifiersFindResultData, IdentifiersFindResultDataFiltersParameters, IdentifiersFindResultDataKeywords, IdentifiersFindResultDataSortParameters } from './priceband/identifiersFindResult';
+export declare enum PriceBandFindResultFields {
+    COLUMN_ACTION_FLAGS = "actionFlags",
+    COLUMN_BILLING = "billing",
+    COLUMN_CURRENCY = "currency",
+    COLUMN_IS_ENABLED = "isEnabled",
+    COLUMN_MARKETPLACE = "marketplace",
+    COLUMN_PRICES = "prices",
+    COLUMN_SALE_CONSTRAINTS = "saleConstraints",
+    COLUMN_IDENTIFIERS = "identifiers"
+}
+export declare type PriceBandFindResultData = {
+    [PriceBandFindResultFields.COLUMN_ACTION_FLAGS]: PriceBandActionFlagsFindResultData;
+    [PriceBandFindResultFields.COLUMN_BILLING]: BillingFindResultData;
+    [PriceBandFindResultFields.COLUMN_CURRENCY]: string;
+    [PriceBandFindResultFields.COLUMN_IS_ENABLED]: boolean;
+    [PriceBandFindResultFields.COLUMN_MARKETPLACE]: string;
+    [PriceBandFindResultFields.COLUMN_PRICES]: PriceBandPriceFindResultData;
+    [PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS]: SaleConstraintsFindResultData;
+    [PriceBandFindResultFields.COLUMN_IDENTIFIERS]: IdentifiersFindResultData;
+};
+export declare type PriceBandFindResultDataKeywords = {
+    [PriceBandFindResultFields.COLUMN_ACTION_FLAGS]?: PriceBandActionFlagsFindResultDataKeywords;
+    [PriceBandFindResultFields.COLUMN_BILLING]?: BillingFindResultDataKeywords;
+    [PriceBandFindResultFields.COLUMN_CURRENCY]?: DataKeywords;
+    [PriceBandFindResultFields.COLUMN_IS_ENABLED]?: DataKeywords;
+    [PriceBandFindResultFields.COLUMN_MARKETPLACE]?: DataKeywords;
+    [PriceBandFindResultFields.COLUMN_PRICES]?: PriceBandPriceFindResultDataKeywords;
+    [PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS]?: SaleConstraintsFindResultDataKeywords;
+    [PriceBandFindResultFields.COLUMN_IDENTIFIERS]?: IdentifiersFindResultDataKeywords;
+};
+export declare type PriceBandFindResultDataSortParameters = {
+    [PriceBandFindResultFields.COLUMN_ACTION_FLAGS]?: PriceBandActionFlagsDataFindResultSortParameters;
+    [PriceBandFindResultFields.COLUMN_BILLING]?: BillingFindResultDataSortParameters;
+    [PriceBandFindResultFields.COLUMN_CURRENCY]?: SortParameters;
+    [PriceBandFindResultFields.COLUMN_IS_ENABLED]?: SortParameters;
+    [PriceBandFindResultFields.COLUMN_MARKETPLACE]?: SortParameters;
+    [PriceBandFindResultFields.COLUMN_PRICES]?: PriceBandPriceFindResultDataSortParameters;
+    [PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS]?: SaleConstraintsFindResultDataSortParameters;
+    [PriceBandFindResultFields.COLUMN_IDENTIFIERS]?: IdentifiersFindResultDataSortParameters;
+};
+export declare type PriceBandFindResultDataFiltersParameters = {
+    [PriceBandFindResultFields.COLUMN_ACTION_FLAGS]?: PriceBandActionFlagsFindResultDataFiltersParameters;
+    [PriceBandFindResultFields.COLUMN_BILLING]?: BillingFindResultDataFiltersParameters;
+    [PriceBandFindResultFields.COLUMN_CURRENCY]?: FiltersParameters;
+    [PriceBandFindResultFields.COLUMN_IS_ENABLED]?: FiltersParameters;
+    [PriceBandFindResultFields.COLUMN_MARKETPLACE]?: FiltersParameters;
+    [PriceBandFindResultFields.COLUMN_PRICES]?: PriceBandPriceFindResultDataFiltersParameters;
+    [PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS]?: SaleConstraintsFindResultDataFiltersParameters;
+    [PriceBandFindResultFields.COLUMN_IDENTIFIERS]?: IdentifiersFindResultDataFiltersParameters;
+};
+export declare class PriceBandFindResult extends AbstractEntity<PriceBandFindResultData> {
+    #private;
+    protected VALIDATION_RULES: Rules;
+    constructor(data: PriceBandFindResultData);
+    get actionFlags(): PriceBandActionFlagsFindResult;
+    get billing(): BillingFindResult;
+    get currency(): string;
+    get isEnabled(): boolean;
+    get marketplace(): string;
+    get prices(): PriceBandPriceFindResult;
+    get saleConstraints(): SaleConstraintsFindResult;
+    get identifiers(): IdentifiersFindResult;
+    toJSON(): PriceBandFindResultData;
+}

package/build/licenses/entities/offer/priceBandFindResult.js

@@ -0,0 +1,131 @@
+"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 _actionFlags, _billing, _currency, _isEnabled, _marketplace, _prices, _saleConstraints, _identifiers;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceBandFindResult = exports.PriceBandFindResultFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const priceBandActionFlagsFindResult_1 = require("./priceband/priceBandActionFlagsFindResult");
+const billingFindResult_1 = require("./priceband/billingFindResult");
+const priceBandPriceFindResult_1 = require("./priceband/priceBandPriceFindResult");
+const saleConstraintsFindResult_1 = require("./priceband/saleConstraintsFindResult");
+const identifiersFindResult_1 = require("./priceband/identifiersFindResult");
+const arrowsphereFindResult_1 = require("./priceband/identifiers/arrowsphereFindResult");
+var PriceBandFindResultFields;
+(function (PriceBandFindResultFields) {
+    PriceBandFindResultFields["COLUMN_ACTION_FLAGS"] = "actionFlags";
+    PriceBandFindResultFields["COLUMN_BILLING"] = "billing";
+    PriceBandFindResultFields["COLUMN_CURRENCY"] = "currency";
+    PriceBandFindResultFields["COLUMN_IS_ENABLED"] = "isEnabled";
+    PriceBandFindResultFields["COLUMN_MARKETPLACE"] = "marketplace";
+    PriceBandFindResultFields["COLUMN_PRICES"] = "prices";
+    PriceBandFindResultFields["COLUMN_SALE_CONSTRAINTS"] = "saleConstraints";
+    PriceBandFindResultFields["COLUMN_IDENTIFIERS"] = "identifiers";
+})(PriceBandFindResultFields = exports.PriceBandFindResultFields || (exports.PriceBandFindResultFields = {}));
+class PriceBandFindResult extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        this.VALIDATION_RULES = {
+            [PriceBandFindResultFields.COLUMN_ACTION_FLAGS]: 'required|array',
+            [PriceBandFindResultFields.COLUMN_BILLING]: 'required|array',
+            [PriceBandFindResultFields.COLUMN_CURRENCY]: 'required',
+            [PriceBandFindResultFields.COLUMN_IS_ENABLED]: 'required|boolean',
+            [PriceBandFindResultFields.COLUMN_MARKETPLACE]: 'required',
+            [PriceBandFindResultFields.COLUMN_PRICES]: 'required|array',
+            [PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS]: 'required|array',
+            [PriceBandFindResultFields.COLUMN_IDENTIFIERS]: 'required|array',
+        };
+        _actionFlags.set(this, void 0);
+        _billing.set(this, void 0);
+        _currency.set(this, void 0);
+        _isEnabled.set(this, void 0);
+        _marketplace.set(this, void 0);
+        _prices.set(this, void 0);
+        _saleConstraints.set(this, void 0);
+        _identifiers.set(this, void 0);
+        const actionFlags = {
+            [priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_CANCELLED]: data[PriceBandFindResultFields.COLUMN_ACTION_FLAGS][priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_CANCELLED],
+            [priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_REACTIVATED]: data[PriceBandFindResultFields.COLUMN_ACTION_FLAGS][priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_REACTIVATED],
+            [priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_SUSPENDED]: data[PriceBandFindResultFields.COLUMN_ACTION_FLAGS][priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_BE_SUSPENDED],
+            [priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_DECREASE_SEATS]: data[PriceBandFindResultFields.COLUMN_ACTION_FLAGS][priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_DECREASE_SEATS],
+            [priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_INCREASE_SEATS]: data[PriceBandFindResultFields.COLUMN_ACTION_FLAGS][priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResultFields.COLUMN_CAN_INCREASE_SEATS],
+        };
+        __classPrivateFieldSet(this, _actionFlags, new priceBandActionFlagsFindResult_1.PriceBandActionFlagsFindResult(actionFlags));
+        const billing = {
+            [billingFindResult_1.BillingFindResultFields.COLUMN_CYCLE]: data[PriceBandFindResultFields.COLUMN_BILLING][billingFindResult_1.BillingFindResultFields.COLUMN_CYCLE],
+            [billingFindResult_1.BillingFindResultFields.COLUMN_TERM]: data[PriceBandFindResultFields.COLUMN_BILLING][billingFindResult_1.BillingFindResultFields.COLUMN_TERM],
+            [billingFindResult_1.BillingFindResultFields.COLUMN_TYPE]: data[PriceBandFindResultFields.COLUMN_BILLING][billingFindResult_1.BillingFindResultFields.COLUMN_TYPE],
+        };
+        __classPrivateFieldSet(this, _billing, new billingFindResult_1.BillingFindResult(billing));
+        __classPrivateFieldSet(this, _currency, data[PriceBandFindResultFields.COLUMN_CURRENCY]);
+        __classPrivateFieldSet(this, _isEnabled, data[PriceBandFindResultFields.COLUMN_IS_ENABLED]);
+        __classPrivateFieldSet(this, _marketplace, data[PriceBandFindResultFields.COLUMN_MARKETPLACE]);
+        const prices = {
+            [priceBandPriceFindResult_1.PriceBandPriceFindResultFields.COLUMN_BUY]: data[PriceBandFindResultFields.COLUMN_PRICES][priceBandPriceFindResult_1.PriceBandPriceFindResultFields.COLUMN_BUY],
+            [priceBandPriceFindResult_1.PriceBandPriceFindResultFields.COLUMN_SELL]: data[PriceBandFindResultFields.COLUMN_PRICES][priceBandPriceFindResult_1.PriceBandPriceFindResultFields.COLUMN_SELL],
+            [priceBandPriceFindResult_1.PriceBandPriceFindResultFields.COLUMN_PUBLIC]: data[PriceBandFindResultFields.COLUMN_PRICES][priceBandPriceFindResult_1.PriceBandPriceFindResultFields.COLUMN_PUBLIC],
+        };
+        __classPrivateFieldSet(this, _prices, new priceBandPriceFindResult_1.PriceBandPriceFindResult(prices));
+        const saleConstraints = {
+            [saleConstraintsFindResult_1.SaleConstraintsFindResultFields.COLUMN_MIN_QUANTITY]: data[PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS][saleConstraintsFindResult_1.SaleConstraintsFindResultFields.COLUMN_MIN_QUANTITY],
+            [saleConstraintsFindResult_1.SaleConstraintsFindResultFields.COLUMN_MAX_QUANTITY]: data[PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS][saleConstraintsFindResult_1.SaleConstraintsFindResultFields.COLUMN_MAX_QUANTITY],
+        };
+        __classPrivateFieldSet(this, _saleConstraints, new saleConstraintsFindResult_1.SaleConstraintsFindResult(saleConstraints));
+        const identifiers = {
+            [identifiersFindResult_1.IdentifiersFindResultFields.COLUMN_ARROWSPHERE]: {
+                [arrowsphereFindResult_1.ArrowsphereFindResultFields.COLUMN_SKU]: data[PriceBandFindResultFields.COLUMN_IDENTIFIERS][identifiersFindResult_1.IdentifiersFindResultFields.COLUMN_ARROWSPHERE][arrowsphereFindResult_1.ArrowsphereFindResultFields.COLUMN_SKU],
+            },
+        };
+        __classPrivateFieldSet(this, _identifiers, new identifiersFindResult_1.IdentifiersFindResult(identifiers));
+    }
+    get actionFlags() {
+        return __classPrivateFieldGet(this, _actionFlags);
+    }
+    get billing() {
+        return __classPrivateFieldGet(this, _billing);
+    }
+    get currency() {
+        return __classPrivateFieldGet(this, _currency);
+    }
+    get isEnabled() {
+        return __classPrivateFieldGet(this, _isEnabled);
+    }
+    get marketplace() {
+        return __classPrivateFieldGet(this, _marketplace);
+    }
+    get prices() {
+        return __classPrivateFieldGet(this, _prices);
+    }
+    get saleConstraints() {
+        return __classPrivateFieldGet(this, _saleConstraints);
+    }
+    get identifiers() {
+        return __classPrivateFieldGet(this, _identifiers);
+    }
+    toJSON() {
+        return {
+            [PriceBandFindResultFields.COLUMN_ACTION_FLAGS]: this.actionFlags.toJSON(),
+            [PriceBandFindResultFields.COLUMN_BILLING]: this.billing.toJSON(),
+            [PriceBandFindResultFields.COLUMN_CURRENCY]: this.currency,
+            [PriceBandFindResultFields.COLUMN_IS_ENABLED]: this.isEnabled,
+            [PriceBandFindResultFields.COLUMN_MARKETPLACE]: this.marketplace,
+            [PriceBandFindResultFields.COLUMN_PRICES]: this.prices.toJSON(),
+            [PriceBandFindResultFields.COLUMN_SALE_CONSTRAINTS]: this.saleConstraints.toJSON(),
+            [PriceBandFindResultFields.COLUMN_IDENTIFIERS]: this.identifiers.toJSON(),
+        };
+    }
+}
+exports.PriceBandFindResult = PriceBandFindResult;
+_actionFlags = new WeakMap(), _billing = new WeakMap(), _currency = new WeakMap(), _isEnabled = new WeakMap(), _marketplace = new WeakMap(), _prices = new WeakMap(), _saleConstraints = new WeakMap(), _identifiers = new WeakMap();
+//# sourceMappingURL=priceBandFindResult.js.map

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

@@ -0,0 +1,37 @@
+import { DataKeywords, FiltersParameters, SortParameters } from '../../../licensesClient';
+import { AbstractEntity } from '../../../../abstractEntity';
+import { Rules } from 'validatorjs';
+export declare enum BillingFindResultFields {
+    COLUMN_CYCLE = "cycle",
+    COLUMN_TERM = "term",
+    COLUMN_TYPE = "type"
+}
+export declare type BillingFindResultData = {
+    [BillingFindResultFields.COLUMN_CYCLE]: number;
+    [BillingFindResultFields.COLUMN_TERM]: number;
+    [BillingFindResultFields.COLUMN_TYPE]: string;
+};
+export declare type BillingFindResultDataKeywords = {
+    [BillingFindResultFields.COLUMN_CYCLE]?: DataKeywords;
+    [BillingFindResultFields.COLUMN_TERM]?: DataKeywords;
+    [BillingFindResultFields.COLUMN_TYPE]?: DataKeywords;
+};
+export declare type BillingFindResultDataSortParameters = {
+    [BillingFindResultFields.COLUMN_CYCLE]?: SortParameters;
+    [BillingFindResultFields.COLUMN_TERM]?: SortParameters;
+    [BillingFindResultFields.COLUMN_TYPE]?: SortParameters;
+};
+export declare type BillingFindResultDataFiltersParameters = {
+    [BillingFindResultFields.COLUMN_CYCLE]?: FiltersParameters;
+    [BillingFindResultFields.COLUMN_TERM]?: FiltersParameters;
+    [BillingFindResultFields.COLUMN_TYPE]?: FiltersParameters;
+};
+export declare class BillingFindResult extends AbstractEntity<BillingFindResultData> {
+    #private;
+    protected VALIDATION_RULES: Rules;
+    constructor(data: BillingFindResultData);
+    get cycle(): number;
+    get term(): number;
+    get type(): string;
+    toJSON(): BillingFindResultData;
+}

package/build/licenses/entities/offer/priceband/billingFindResult.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 _cycle, _term, _type;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingFindResult = exports.BillingFindResultFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+var BillingFindResultFields;
+(function (BillingFindResultFields) {
+    BillingFindResultFields["COLUMN_CYCLE"] = "cycle";
+    BillingFindResultFields["COLUMN_TERM"] = "term";
+    BillingFindResultFields["COLUMN_TYPE"] = "type";
+})(BillingFindResultFields = exports.BillingFindResultFields || (exports.BillingFindResultFields = {}));
+class BillingFindResult extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        this.VALIDATION_RULES = {
+            [BillingFindResultFields.COLUMN_CYCLE]: 'required|numeric',
+            [BillingFindResultFields.COLUMN_TERM]: 'required|numeric',
+            [BillingFindResultFields.COLUMN_TYPE]: 'required|string',
+        };
+        _cycle.set(this, void 0);
+        _term.set(this, void 0);
+        _type.set(this, void 0);
+        __classPrivateFieldSet(this, _cycle, data[BillingFindResultFields.COLUMN_CYCLE]);
+        __classPrivateFieldSet(this, _term, data[BillingFindResultFields.COLUMN_TERM]);
+        __classPrivateFieldSet(this, _type, data[BillingFindResultFields.COLUMN_TYPE]);
+    }
+    get cycle() {
+        return __classPrivateFieldGet(this, _cycle);
+    }
+    get term() {
+        return __classPrivateFieldGet(this, _term);
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _type);
+    }
+    toJSON() {
+        return {
+            [BillingFindResultFields.COLUMN_CYCLE]: this.cycle,
+            [BillingFindResultFields.COLUMN_TERM]: this.term,
+            [BillingFindResultFields.COLUMN_TYPE]: this.type,
+        };
+    }
+}
+exports.BillingFindResult = BillingFindResult;
+_cycle = new WeakMap(), _term = new WeakMap(), _type = new WeakMap();
+//# sourceMappingURL=billingFindResult.js.map

package/build/licenses/entities/offer/priceband/identifiers/arrowsphereFindResult.d.ts

@@ -0,0 +1,25 @@
+import { AbstractEntity } from '../../../../../abstractEntity';
+import { Rules } from 'validatorjs';
+import { DataKeywords, FiltersParameters, SortParameters } from '../../../../licensesClient';
+export declare enum ArrowsphereFindResultFields {
+    COLUMN_SKU = "sku"
+}
+export declare type ArrowsphereFindResultData = {
+    [ArrowsphereFindResultFields.COLUMN_SKU]: string;
+};
+export declare type ArrowsphereFindResultDataKeywords = {
+    [ArrowsphereFindResultFields.COLUMN_SKU]?: DataKeywords;
+};
+export declare type ArrowsphereFindResultDataSortParameters = {
+    [ArrowsphereFindResultFields.COLUMN_SKU]?: SortParameters;
+};
+export declare type ArrowsphereFindResultDataFiltersParameters = {
+    [ArrowsphereFindResultFields.COLUMN_SKU]?: FiltersParameters;
+};
+export declare class ArrowsphereFindResult extends AbstractEntity<ArrowsphereFindResultData> {
+    #private;
+    protected VALIDATION_RULES: Rules;
+    constructor(data: ArrowsphereFindResultData);
+    get arrowsphereSku(): string;
+    toJSON(): ArrowsphereFindResultData;
+}

package/build/licenses/entities/offer/priceband/identifiers/arrowsphereFindResult.js

@@ -0,0 +1,43 @@
+"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 _arrowsphereSku;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrowsphereFindResult = exports.ArrowsphereFindResultFields = void 0;
+const abstractEntity_1 = require("../../../../../abstractEntity");
+var ArrowsphereFindResultFields;
+(function (ArrowsphereFindResultFields) {
+    ArrowsphereFindResultFields["COLUMN_SKU"] = "sku";
+})(ArrowsphereFindResultFields = exports.ArrowsphereFindResultFields || (exports.ArrowsphereFindResultFields = {}));
+class ArrowsphereFindResult extends abstractEntity_1.AbstractEntity {
+    constructor(data) {
+        super(data);
+        this.VALIDATION_RULES = {
+            [ArrowsphereFindResultFields.COLUMN_SKU]: 'present|string',
+        };
+        _arrowsphereSku.set(this, void 0);
+        __classPrivateFieldSet(this, _arrowsphereSku, data[ArrowsphereFindResultFields.COLUMN_SKU]);
+    }
+    get arrowsphereSku() {
+        return __classPrivateFieldGet(this, _arrowsphereSku);
+    }
+    toJSON() {
+        return {
+            [ArrowsphereFindResultFields.COLUMN_SKU]: this.arrowsphereSku,
+        };
+    }
+}
+exports.ArrowsphereFindResult = ArrowsphereFindResult;
+_arrowsphereSku = new WeakMap();
+//# sourceMappingURL=arrowsphereFindResult.js.map

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

@@ -0,0 +1,25 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+import { Rules } from 'validatorjs';
+import { ArrowsphereFindResult, ArrowsphereFindResultData, ArrowsphereFindResultDataFiltersParameters, ArrowsphereFindResultDataKeywords, ArrowsphereFindResultDataSortParameters } from './identifiers/arrowsphereFindResult';
+export declare enum IdentifiersFindResultFields {
+    COLUMN_ARROWSPHERE = "arrowsphere"
+}
+export declare type IdentifiersFindResultData = {
+    [IdentifiersFindResultFields.COLUMN_ARROWSPHERE]: ArrowsphereFindResultData;
+};
+export declare type IdentifiersFindResultDataKeywords = {
+    [IdentifiersFindResultFields.COLUMN_ARROWSPHERE]: ArrowsphereFindResultDataKeywords;
+};
+export declare type IdentifiersFindResultDataSortParameters = {
+    [IdentifiersFindResultFields.COLUMN_ARROWSPHERE]: ArrowsphereFindResultDataSortParameters;
+};
+export declare type IdentifiersFindResultDataFiltersParameters = {
+    [IdentifiersFindResultFields.COLUMN_ARROWSPHERE]: ArrowsphereFindResultDataFiltersParameters;
+};
+export declare class IdentifiersFindResult extends AbstractEntity<IdentifiersFindResultData> {
+    #private;
+    protected VALIDATION_RULES: Rules;
+    constructor(data: IdentifiersFindResultData);
+    get arrowsphere(): ArrowsphereFindResult;
+    toJSON(): IdentifiersFindResultData;
+}