@arrowsphere/api-client 3.385.0-rc-cpe-1 → 3.385.0-rc-cpe-2

package/build/licenses/entities/getLicense/licensePriceGetResult.d.ts

@@ -1,5 +1,7 @@
 import { BuySellData, BuySellFindResult } from './buySellFindResult';
 import { AbstractEntity } from '../../../abstractEntity';
+import { ProductPricesFields } from '../../../orders';
+import { LicensePreferredCurrencyType } from '../license/licensePreferredCurrency';
 export declare enum LicensePriceGetFields {
     COLUMN_CURRENCY = "currency",
     COLUMN_PRICEBAND_ARROWSPHERE_SKU = "priceBandArrowsphereSku",
@@ -11,6 +13,7 @@ export declare type LicensePriceGetData = {
     [LicensePriceGetFields.COLUMN_PRICEBAND_ARROWSPHERE_SKU]: string;
     [LicensePriceGetFields.COLUMN_UNIT]: BuySellData;
     [LicensePriceGetFields.COLUMN_TOTAL]: BuySellData;
+    [ProductPricesFields.COLUMN_PREFERRED_CURRENCY]?: LicensePreferredCurrencyType;
 };
 export declare class LicensePriceGetResult extends AbstractEntity<LicensePriceGetData> {
     #private;

package/build/licenses/entities/getLicense/licensePriceGetResult.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LicensePriceGetResult = exports.LicensePriceGetFields = void 0;
 const buySellFindResult_1 = require("./buySellFindResult");
 const abstractEntity_1 = require("../../../abstractEntity");
+const orders_1 = require("../../../orders");
 var LicensePriceGetFields;
 (function (LicensePriceGetFields) {
     LicensePriceGetFields["COLUMN_CURRENCY"] = "currency";

package/build/licenses/entities/license/licensePreferredCurrency/licenseConversionRules.d.ts

@@ -0,0 +1,19 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+export declare enum LicenseConversionRulesFields {
+    COLUMN_CURRENCY = "currency",
+    COLUMN_EXCHANGE_RATE_DATE = "exchangeRateDate",
+    COLUMN_EXCHANGE_RATE = "exchangeRate"
+}
+export declare type LicenseConversionRulesType = {
+    [LicenseConversionRulesFields.COLUMN_CURRENCY]: string;
+    [LicenseConversionRulesFields.COLUMN_EXCHANGE_RATE_DATE]: string;
+    [LicenseConversionRulesFields.COLUMN_EXCHANGE_RATE]: number;
+};
+export declare class LicenseConversionRules extends AbstractEntity<LicenseConversionRulesType> {
+    #private;
+    constructor(input: LicenseConversionRulesType);
+    get currency(): string;
+    get exchangeRateDate(): string;
+    get exchangeRate(): number;
+    toJSON(): LicenseConversionRulesType;
+}

package/build/licenses/entities/license/licensePreferredCurrency/licenseConversionRules.js

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

package/build/licenses/entities/license/licensePreferredCurrency/licensePreferredCurrencyValues.d.ts

@@ -0,0 +1,17 @@
+import { AbstractEntity } from '../../../../abstractEntity';
+import { BuySellData, BuySellFindResult } from '../../getLicense/buySellFindResult';
+export declare enum LicensePreferredCurrencyValuesFields {
+    COLUMN_UNIT = "unit",
+    COLUMN_TOTAL = "total"
+}
+export declare type LicensePreferredCurrencyValuesType = {
+    [LicensePreferredCurrencyValuesFields.COLUMN_UNIT]: BuySellData;
+    [LicensePreferredCurrencyValuesFields.COLUMN_TOTAL]: BuySellData;
+};
+export declare class LicensePreferredCurrencyValues extends AbstractEntity<LicensePreferredCurrencyValuesType> {
+    #private;
+    constructor(input: LicensePreferredCurrencyValuesType);
+    get unit(): BuySellFindResult;
+    get total(): BuySellFindResult;
+    toJSON(): LicensePreferredCurrencyValuesType;
+}

package/build/licenses/entities/license/licensePreferredCurrency/licensePreferredCurrencyValues.js

@@ -0,0 +1,46 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LicensePreferredCurrencyValues_unit, _LicensePreferredCurrencyValues_total;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicensePreferredCurrencyValues = exports.LicensePreferredCurrencyValuesFields = void 0;
+const abstractEntity_1 = require("../../../../abstractEntity");
+const buySellFindResult_1 = require("../../getLicense/buySellFindResult");
+var LicensePreferredCurrencyValuesFields;
+(function (LicensePreferredCurrencyValuesFields) {
+    LicensePreferredCurrencyValuesFields["COLUMN_UNIT"] = "unit";
+    LicensePreferredCurrencyValuesFields["COLUMN_TOTAL"] = "total";
+})(LicensePreferredCurrencyValuesFields = exports.LicensePreferredCurrencyValuesFields || (exports.LicensePreferredCurrencyValuesFields = {}));
+class LicensePreferredCurrencyValues extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _LicensePreferredCurrencyValues_unit.set(this, void 0);
+        _LicensePreferredCurrencyValues_total.set(this, void 0);
+        __classPrivateFieldSet(this, _LicensePreferredCurrencyValues_unit, new buySellFindResult_1.BuySellFindResult(input[LicensePreferredCurrencyValuesFields.COLUMN_UNIT]), "f");
+        __classPrivateFieldSet(this, _LicensePreferredCurrencyValues_total, new buySellFindResult_1.BuySellFindResult(input[LicensePreferredCurrencyValuesFields.COLUMN_TOTAL]), "f");
+    }
+    get unit() {
+        return __classPrivateFieldGet(this, _LicensePreferredCurrencyValues_unit, "f");
+    }
+    get total() {
+        return __classPrivateFieldGet(this, _LicensePreferredCurrencyValues_total, "f");
+    }
+    toJSON() {
+        return {
+            [LicensePreferredCurrencyValuesFields.COLUMN_UNIT]: this.unit.toJSON(),
+            [LicensePreferredCurrencyValuesFields.COLUMN_TOTAL]: this.total.toJSON(),
+        };
+    }
+}
+exports.LicensePreferredCurrencyValues = LicensePreferredCurrencyValues;
+_LicensePreferredCurrencyValues_unit = new WeakMap(), _LicensePreferredCurrencyValues_total = new WeakMap();
+//# sourceMappingURL=licensePreferredCurrencyValues.js.map

package/build/licenses/entities/license/licensePreferredCurrency.d.ts

@@ -0,0 +1,18 @@
+import { AbstractEntity } from '../../../abstractEntity';
+import { LicenseConversionRules, LicenseConversionRulesType } from './licensePreferredCurrency/licenseConversionRules';
+import { LicensePreferredCurrencyValues, LicensePreferredCurrencyValuesType } from './licensePreferredCurrency/licensePreferredCurrencyValues';
+export declare enum LicensePreferredCurrencyFields {
+    COLUMN_CONVERSION_RULES = "conversionRules",
+    COLUMN_VALUES = "values"
+}
+export declare type LicensePreferredCurrencyType = {
+    [LicensePreferredCurrencyFields.COLUMN_CONVERSION_RULES]: LicenseConversionRulesType;
+    [LicensePreferredCurrencyFields.COLUMN_VALUES]: LicensePreferredCurrencyValuesType;
+};
+export declare class LicensePreferredCurrency extends AbstractEntity<LicensePreferredCurrencyType> {
+    #private;
+    constructor(input: LicensePreferredCurrencyType);
+    get conversionRules(): LicenseConversionRules;
+    get values(): LicensePreferredCurrencyValues;
+    toJSON(): LicensePreferredCurrencyType;
+}

package/build/licenses/entities/license/licensePreferredCurrency.js

@@ -0,0 +1,47 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LicensePreferredCurrency_conversionRules, _LicensePreferredCurrency_values;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicensePreferredCurrency = exports.LicensePreferredCurrencyFields = void 0;
+const abstractEntity_1 = require("../../../abstractEntity");
+const licenseConversionRules_1 = require("./licensePreferredCurrency/licenseConversionRules");
+const licensePreferredCurrencyValues_1 = require("./licensePreferredCurrency/licensePreferredCurrencyValues");
+var LicensePreferredCurrencyFields;
+(function (LicensePreferredCurrencyFields) {
+    LicensePreferredCurrencyFields["COLUMN_CONVERSION_RULES"] = "conversionRules";
+    LicensePreferredCurrencyFields["COLUMN_VALUES"] = "values";
+})(LicensePreferredCurrencyFields = exports.LicensePreferredCurrencyFields || (exports.LicensePreferredCurrencyFields = {}));
+class LicensePreferredCurrency extends abstractEntity_1.AbstractEntity {
+    constructor(input) {
+        super(input);
+        _LicensePreferredCurrency_conversionRules.set(this, void 0);
+        _LicensePreferredCurrency_values.set(this, void 0);
+        __classPrivateFieldSet(this, _LicensePreferredCurrency_conversionRules, new licenseConversionRules_1.LicenseConversionRules(input[LicensePreferredCurrencyFields.COLUMN_CONVERSION_RULES]), "f");
+        __classPrivateFieldSet(this, _LicensePreferredCurrency_values, new licensePreferredCurrencyValues_1.LicensePreferredCurrencyValues(input[LicensePreferredCurrencyFields.COLUMN_VALUES]), "f");
+    }
+    get conversionRules() {
+        return __classPrivateFieldGet(this, _LicensePreferredCurrency_conversionRules, "f");
+    }
+    get values() {
+        return __classPrivateFieldGet(this, _LicensePreferredCurrency_values, "f");
+    }
+    toJSON() {
+        return {
+            [LicensePreferredCurrencyFields.COLUMN_CONVERSION_RULES]: this.conversionRules.toJSON(),
+            [LicensePreferredCurrencyFields.COLUMN_VALUES]: this.values.toJSON(),
+        };
+    }
+}
+exports.LicensePreferredCurrency = LicensePreferredCurrency;
+_LicensePreferredCurrency_conversionRules = new WeakMap(), _LicensePreferredCurrency_values = new WeakMap();
+//# sourceMappingURL=licensePreferredCurrency.js.map

package/package.json

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