@arrowsphere/api-client 3.152.0 → 3.153.0

package/build/orderSoftware/entities/dataListOrderSoftware.d.ts

@@ -0,0 +1,14 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { OrderSoftware, OrderSoftwareType } from './orderSoftware';
+export declare enum DataListOrdersSoftwareFields {
+    COLUMN_ORDERS = "orders"
+}
+export declare type DataListOrdersSoftwareType = {
+    [DataListOrdersSoftwareFields.COLUMN_ORDERS]: Array<OrderSoftwareType>;
+};
+export declare class DataListOrdersSoftware extends AbstractEntity<DataListOrdersSoftwareType> {
+    #private;
+    constructor(orderList: DataListOrdersSoftwareType);
+    get orders(): Array<OrderSoftware>;
+    toJSON(): DataListOrdersSoftwareType;
+}

package/build/orderSoftware/entities/dataListOrderSoftware.js

@@ -0,0 +1,39 @@
+"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 _DataListOrdersSoftware_orders;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataListOrdersSoftware = exports.DataListOrdersSoftwareFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const orderSoftware_1 = require("./orderSoftware");
+var DataListOrdersSoftwareFields;
+(function (DataListOrdersSoftwareFields) {
+    DataListOrdersSoftwareFields["COLUMN_ORDERS"] = "orders";
+})(DataListOrdersSoftwareFields = exports.DataListOrdersSoftwareFields || (exports.DataListOrdersSoftwareFields = {}));
+class DataListOrdersSoftware extends abstractEntity_1.AbstractEntity {
+    constructor(orderList) {
+        super(orderList);
+        _DataListOrdersSoftware_orders.set(this, void 0);
+        __classPrivateFieldSet(this, _DataListOrdersSoftware_orders, orderList[DataListOrdersSoftwareFields.COLUMN_ORDERS].map((orderSoftware) => new orderSoftware_1.OrderSoftware(orderSoftware)), "f");
+    }
+    get orders() {
+        return __classPrivateFieldGet(this, _DataListOrdersSoftware_orders, "f");
+    }
+    toJSON() {
+        return {
+            [DataListOrdersSoftwareFields.COLUMN_ORDERS]: this.orders.map((orderSoftware) => orderSoftware.toJSON()),
+        };
+    }
+}
+exports.DataListOrdersSoftware = DataListOrdersSoftware;
+_DataListOrdersSoftware_orders = new WeakMap();
+//# sourceMappingURL=dataListOrderSoftware.js.map

package/build/orderSoftware/entities/orderSoftware.d.ts

@@ -0,0 +1,30 @@
+import { OrderSoftwareProduct, OrderSoftwareProductType } from './orderSoftwareProduct';
+import { OrderSoftwareReference, OrderSoftwareReferenceType } from './orderSoftwareReference';
+import { AbstractEntity } from '../../abstractEntity';
+export declare enum OrderSoftwareFields {
+    COLUMN_REFERENCE = "reference",
+    COLUMN_STATUS = "status",
+    COLUMN_PROGRAM = "program",
+    COLUMN_PRODUCTS = "products",
+    COLUMN_SUBSCRIPTION = "subscription",
+    COLUMN_REPORT = "report"
+}
+export declare type OrderSoftwareType = {
+    [OrderSoftwareFields.COLUMN_REFERENCE]: string;
+    [OrderSoftwareFields.COLUMN_STATUS]: string;
+    [OrderSoftwareFields.COLUMN_PROGRAM]: string;
+    [OrderSoftwareFields.COLUMN_PRODUCTS]: Array<OrderSoftwareProductType>;
+    [OrderSoftwareFields.COLUMN_SUBSCRIPTION]: OrderSoftwareReferenceType;
+    [OrderSoftwareFields.COLUMN_REPORT]: OrderSoftwareReferenceType;
+};
+export declare class OrderSoftware extends AbstractEntity<OrderSoftwareType> {
+    #private;
+    constructor(orderSoftwareDataInput: OrderSoftwareType);
+    get reference(): string;
+    get status(): string;
+    get program(): string;
+    get products(): Array<OrderSoftwareProduct>;
+    get subscription(): OrderSoftwareReference;
+    get report(): OrderSoftwareReference;
+    toJSON(): OrderSoftwareType;
+}

package/build/orderSoftware/entities/orderSoftware.js

@@ -0,0 +1,75 @@
+"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 _OrderSoftware_reference, _OrderSoftware_status, _OrderSoftware_program, _OrderSoftware_products, _OrderSoftware_subscription, _OrderSoftware_report;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSoftware = exports.OrderSoftwareFields = void 0;
+const orderSoftwareProduct_1 = require("./orderSoftwareProduct");
+const orderSoftwareReference_1 = require("./orderSoftwareReference");
+const abstractEntity_1 = require("../../abstractEntity");
+var OrderSoftwareFields;
+(function (OrderSoftwareFields) {
+    OrderSoftwareFields["COLUMN_REFERENCE"] = "reference";
+    OrderSoftwareFields["COLUMN_STATUS"] = "status";
+    OrderSoftwareFields["COLUMN_PROGRAM"] = "program";
+    OrderSoftwareFields["COLUMN_PRODUCTS"] = "products";
+    OrderSoftwareFields["COLUMN_SUBSCRIPTION"] = "subscription";
+    OrderSoftwareFields["COLUMN_REPORT"] = "report";
+})(OrderSoftwareFields = exports.OrderSoftwareFields || (exports.OrderSoftwareFields = {}));
+class OrderSoftware extends abstractEntity_1.AbstractEntity {
+    constructor(orderSoftwareDataInput) {
+        super(orderSoftwareDataInput);
+        _OrderSoftware_reference.set(this, void 0);
+        _OrderSoftware_status.set(this, void 0);
+        _OrderSoftware_program.set(this, void 0);
+        _OrderSoftware_products.set(this, void 0);
+        _OrderSoftware_subscription.set(this, void 0);
+        _OrderSoftware_report.set(this, void 0);
+        __classPrivateFieldSet(this, _OrderSoftware_reference, orderSoftwareDataInput[OrderSoftwareFields.COLUMN_REFERENCE], "f");
+        __classPrivateFieldSet(this, _OrderSoftware_status, orderSoftwareDataInput[OrderSoftwareFields.COLUMN_STATUS], "f");
+        __classPrivateFieldSet(this, _OrderSoftware_program, orderSoftwareDataInput[OrderSoftwareFields.COLUMN_PROGRAM], "f");
+        __classPrivateFieldSet(this, _OrderSoftware_products, orderSoftwareDataInput[OrderSoftwareFields.COLUMN_PRODUCTS].map((product) => new orderSoftwareProduct_1.OrderSoftwareProduct(product)), "f");
+        __classPrivateFieldSet(this, _OrderSoftware_subscription, new orderSoftwareReference_1.OrderSoftwareReference(orderSoftwareDataInput[OrderSoftwareFields.COLUMN_SUBSCRIPTION]), "f");
+        __classPrivateFieldSet(this, _OrderSoftware_report, new orderSoftwareReference_1.OrderSoftwareReference(orderSoftwareDataInput[OrderSoftwareFields.COLUMN_REPORT]), "f");
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _OrderSoftware_reference, "f");
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _OrderSoftware_status, "f");
+    }
+    get program() {
+        return __classPrivateFieldGet(this, _OrderSoftware_program, "f");
+    }
+    get products() {
+        return __classPrivateFieldGet(this, _OrderSoftware_products, "f");
+    }
+    get subscription() {
+        return __classPrivateFieldGet(this, _OrderSoftware_subscription, "f");
+    }
+    get report() {
+        return __classPrivateFieldGet(this, _OrderSoftware_report, "f");
+    }
+    toJSON() {
+        return {
+            [OrderSoftwareFields.COLUMN_REFERENCE]: this.reference,
+            [OrderSoftwareFields.COLUMN_STATUS]: this.status,
+            [OrderSoftwareFields.COLUMN_PROGRAM]: this.program,
+            [OrderSoftwareFields.COLUMN_PRODUCTS]: this.products.map((product) => product.toJSON()),
+            [OrderSoftwareFields.COLUMN_SUBSCRIPTION]: this.subscription.toJSON(),
+            [OrderSoftwareFields.COLUMN_REPORT]: this.report.toJSON(),
+        };
+    }
+}
+exports.OrderSoftware = OrderSoftware;
+_OrderSoftware_reference = new WeakMap(), _OrderSoftware_status = new WeakMap(), _OrderSoftware_program = new WeakMap(), _OrderSoftware_products = new WeakMap(), _OrderSoftware_subscription = new WeakMap(), _OrderSoftware_report = new WeakMap();
+//# sourceMappingURL=orderSoftware.js.map

package/build/orderSoftware/entities/orderSoftwarePrice.d.ts

@@ -0,0 +1,19 @@
+import { AbstractEntity } from '../../abstractEntity';
+export declare enum OrderSoftwarePriceFields {
+    COLUMN_UNIT_PRICE = "unitPrice",
+    COLUMN_TOTAL_PRICE = "totalPrice",
+    COLUMN_CURRENCY = "currency"
+}
+export declare type OrderSoftwarePriceType = {
+    [OrderSoftwarePriceFields.COLUMN_UNIT_PRICE]: number;
+    [OrderSoftwarePriceFields.COLUMN_TOTAL_PRICE]: number;
+    [OrderSoftwarePriceFields.COLUMN_CURRENCY]: string;
+};
+export declare class OrderSoftwarePrice extends AbstractEntity<OrderSoftwarePriceType> {
+    #private;
+    constructor(price: OrderSoftwarePriceType);
+    get unitPrice(): number;
+    get totalPrice(): number;
+    get currency(): string;
+    toJSON(): OrderSoftwarePriceType;
+}

package/build/orderSoftware/entities/orderSoftwarePrice.js

@@ -0,0 +1,52 @@
+"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 _OrderSoftwarePrice_unitPrice, _OrderSoftwarePrice_totalPrice, _OrderSoftwarePrice_currency;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSoftwarePrice = exports.OrderSoftwarePriceFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+var OrderSoftwarePriceFields;
+(function (OrderSoftwarePriceFields) {
+    OrderSoftwarePriceFields["COLUMN_UNIT_PRICE"] = "unitPrice";
+    OrderSoftwarePriceFields["COLUMN_TOTAL_PRICE"] = "totalPrice";
+    OrderSoftwarePriceFields["COLUMN_CURRENCY"] = "currency";
+})(OrderSoftwarePriceFields = exports.OrderSoftwarePriceFields || (exports.OrderSoftwarePriceFields = {}));
+class OrderSoftwarePrice extends abstractEntity_1.AbstractEntity {
+    constructor(price) {
+        super(price);
+        _OrderSoftwarePrice_unitPrice.set(this, void 0);
+        _OrderSoftwarePrice_totalPrice.set(this, void 0);
+        _OrderSoftwarePrice_currency.set(this, void 0);
+        __classPrivateFieldSet(this, _OrderSoftwarePrice_unitPrice, price[OrderSoftwarePriceFields.COLUMN_UNIT_PRICE], "f");
+        __classPrivateFieldSet(this, _OrderSoftwarePrice_totalPrice, price[OrderSoftwarePriceFields.COLUMN_TOTAL_PRICE], "f");
+        __classPrivateFieldSet(this, _OrderSoftwarePrice_currency, price[OrderSoftwarePriceFields.COLUMN_CURRENCY], "f");
+    }
+    get unitPrice() {
+        return __classPrivateFieldGet(this, _OrderSoftwarePrice_unitPrice, "f");
+    }
+    get totalPrice() {
+        return __classPrivateFieldGet(this, _OrderSoftwarePrice_totalPrice, "f");
+    }
+    get currency() {
+        return __classPrivateFieldGet(this, _OrderSoftwarePrice_currency, "f");
+    }
+    toJSON() {
+        return {
+            [OrderSoftwarePriceFields.COLUMN_UNIT_PRICE]: this.unitPrice,
+            [OrderSoftwarePriceFields.COLUMN_TOTAL_PRICE]: this.totalPrice,
+            [OrderSoftwarePriceFields.COLUMN_CURRENCY]: this.currency,
+        };
+    }
+}
+exports.OrderSoftwarePrice = OrderSoftwarePrice;
+_OrderSoftwarePrice_unitPrice = new WeakMap(), _OrderSoftwarePrice_totalPrice = new WeakMap(), _OrderSoftwarePrice_currency = new WeakMap();
+//# sourceMappingURL=orderSoftwarePrice.js.map

package/build/orderSoftware/entities/orderSoftwareProduct.d.ts

@@ -0,0 +1,26 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { OrderSoftwarePrice, OrderSoftwarePriceType } from './orderSoftwarePrice';
+export declare enum OrderSoftwareProductFields {
+    COLUMN_SKU = "sku",
+    COLUMN_PRODUCT_NAME = "productName",
+    COLUMN_PRODUCT_VERSION = "productVersion",
+    COLUMN_QUANTITY = "quantity",
+    COLUMN_PRICE = "price"
+}
+export declare type OrderSoftwareProductType = {
+    [OrderSoftwareProductFields.COLUMN_SKU]: string;
+    [OrderSoftwareProductFields.COLUMN_PRODUCT_NAME]: string;
+    [OrderSoftwareProductFields.COLUMN_PRODUCT_VERSION]: string;
+    [OrderSoftwareProductFields.COLUMN_QUANTITY]: number;
+    [OrderSoftwareProductFields.COLUMN_PRICE]: OrderSoftwarePriceType;
+};
+export declare class OrderSoftwareProduct extends AbstractEntity<OrderSoftwareProductType> {
+    #private;
+    constructor(product: OrderSoftwareProductType);
+    get sku(): string;
+    get productName(): string;
+    get productVersion(): string;
+    get quantity(): number;
+    get price(): OrderSoftwarePrice;
+    toJSON(): OrderSoftwareProductType;
+}

package/build/orderSoftware/entities/orderSoftwareProduct.js

@@ -0,0 +1,67 @@
+"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 _OrderSoftwareProduct_sku, _OrderSoftwareProduct_productName, _OrderSoftwareProduct_productVersion, _OrderSoftwareProduct_quantity, _OrderSoftwareProduct_price;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSoftwareProduct = exports.OrderSoftwareProductFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const orderSoftwarePrice_1 = require("./orderSoftwarePrice");
+var OrderSoftwareProductFields;
+(function (OrderSoftwareProductFields) {
+    OrderSoftwareProductFields["COLUMN_SKU"] = "sku";
+    OrderSoftwareProductFields["COLUMN_PRODUCT_NAME"] = "productName";
+    OrderSoftwareProductFields["COLUMN_PRODUCT_VERSION"] = "productVersion";
+    OrderSoftwareProductFields["COLUMN_QUANTITY"] = "quantity";
+    OrderSoftwareProductFields["COLUMN_PRICE"] = "price";
+})(OrderSoftwareProductFields = exports.OrderSoftwareProductFields || (exports.OrderSoftwareProductFields = {}));
+class OrderSoftwareProduct extends abstractEntity_1.AbstractEntity {
+    constructor(product) {
+        super(product);
+        _OrderSoftwareProduct_sku.set(this, void 0);
+        _OrderSoftwareProduct_productName.set(this, void 0);
+        _OrderSoftwareProduct_productVersion.set(this, void 0);
+        _OrderSoftwareProduct_quantity.set(this, void 0);
+        _OrderSoftwareProduct_price.set(this, void 0);
+        __classPrivateFieldSet(this, _OrderSoftwareProduct_sku, product[OrderSoftwareProductFields.COLUMN_SKU], "f");
+        __classPrivateFieldSet(this, _OrderSoftwareProduct_productName, product[OrderSoftwareProductFields.COLUMN_PRODUCT_NAME], "f");
+        __classPrivateFieldSet(this, _OrderSoftwareProduct_productVersion, product[OrderSoftwareProductFields.COLUMN_PRODUCT_VERSION], "f");
+        __classPrivateFieldSet(this, _OrderSoftwareProduct_quantity, product[OrderSoftwareProductFields.COLUMN_QUANTITY], "f");
+        __classPrivateFieldSet(this, _OrderSoftwareProduct_price, new orderSoftwarePrice_1.OrderSoftwarePrice(product[OrderSoftwareProductFields.COLUMN_PRICE]), "f");
+    }
+    get sku() {
+        return __classPrivateFieldGet(this, _OrderSoftwareProduct_sku, "f");
+    }
+    get productName() {
+        return __classPrivateFieldGet(this, _OrderSoftwareProduct_productName, "f");
+    }
+    get productVersion() {
+        return __classPrivateFieldGet(this, _OrderSoftwareProduct_productVersion, "f");
+    }
+    get quantity() {
+        return __classPrivateFieldGet(this, _OrderSoftwareProduct_quantity, "f");
+    }
+    get price() {
+        return __classPrivateFieldGet(this, _OrderSoftwareProduct_price, "f");
+    }
+    toJSON() {
+        return {
+            [OrderSoftwareProductFields.COLUMN_SKU]: this.sku,
+            [OrderSoftwareProductFields.COLUMN_PRODUCT_NAME]: this.productName,
+            [OrderSoftwareProductFields.COLUMN_PRODUCT_VERSION]: this.productVersion,
+            [OrderSoftwareProductFields.COLUMN_QUANTITY]: this.quantity,
+            [OrderSoftwareProductFields.COLUMN_PRICE]: this.price.toJSON(),
+        };
+    }
+}
+exports.OrderSoftwareProduct = OrderSoftwareProduct;
+_OrderSoftwareProduct_sku = new WeakMap(), _OrderSoftwareProduct_productName = new WeakMap(), _OrderSoftwareProduct_productVersion = new WeakMap(), _OrderSoftwareProduct_quantity = new WeakMap(), _OrderSoftwareProduct_price = new WeakMap();
+//# sourceMappingURL=orderSoftwareProduct.js.map

package/build/orderSoftware/entities/orderSoftwareReference.d.ts

@@ -0,0 +1,16 @@
+import { AbstractEntity } from '../../abstractEntity';
+export declare enum OrderSoftwareReferenceFields {
+    COLUMN_REFERENCE = "reference",
+    COLUMN_LINK = "link"
+}
+export declare type OrderSoftwareReferenceType = {
+    [OrderSoftwareReferenceFields.COLUMN_REFERENCE]: string;
+    [OrderSoftwareReferenceFields.COLUMN_LINK]: string;
+};
+export declare class OrderSoftwareReference extends AbstractEntity<OrderSoftwareReferenceType> {
+    #private;
+    constructor(reference: OrderSoftwareReferenceType);
+    get reference(): string;
+    get link(): string;
+    toJSON(): OrderSoftwareReferenceType;
+}

package/build/orderSoftware/entities/orderSoftwareReference.js

@@ -0,0 +1,45 @@
+"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 _OrderSoftwareReference_reference, _OrderSoftwareReference_link;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSoftwareReference = exports.OrderSoftwareReferenceFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+var OrderSoftwareReferenceFields;
+(function (OrderSoftwareReferenceFields) {
+    OrderSoftwareReferenceFields["COLUMN_REFERENCE"] = "reference";
+    OrderSoftwareReferenceFields["COLUMN_LINK"] = "link";
+})(OrderSoftwareReferenceFields = exports.OrderSoftwareReferenceFields || (exports.OrderSoftwareReferenceFields = {}));
+class OrderSoftwareReference extends abstractEntity_1.AbstractEntity {
+    constructor(reference) {
+        super(reference);
+        _OrderSoftwareReference_reference.set(this, void 0);
+        _OrderSoftwareReference_link.set(this, void 0);
+        __classPrivateFieldSet(this, _OrderSoftwareReference_reference, reference[OrderSoftwareReferenceFields.COLUMN_REFERENCE], "f");
+        __classPrivateFieldSet(this, _OrderSoftwareReference_link, reference[OrderSoftwareReferenceFields.COLUMN_LINK], "f");
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _OrderSoftwareReference_reference, "f");
+    }
+    get link() {
+        return __classPrivateFieldGet(this, _OrderSoftwareReference_link, "f");
+    }
+    toJSON() {
+        return {
+            [OrderSoftwareReferenceFields.COLUMN_REFERENCE]: this.reference,
+            [OrderSoftwareReferenceFields.COLUMN_LINK]: this.link,
+        };
+    }
+}
+exports.OrderSoftwareReference = OrderSoftwareReference;
+_OrderSoftwareReference_reference = new WeakMap(), _OrderSoftwareReference_link = new WeakMap();
+//# sourceMappingURL=orderSoftwareReference.js.map

package/build/orderSoftware/index.d.ts

@@ -0,0 +1,5 @@
+export * from './entities/orderSoftwarePrice';
+export * from './entities/orderSoftwareProduct';
+export * from './entities/orderSoftware';
+export * from './entities/dataListOrderSoftware';
+export * from './orderSoftwareClient';

package/build/orderSoftware/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entities/orderSoftwarePrice"), exports);
+__exportStar(require("./entities/orderSoftwareProduct"), exports);
+__exportStar(require("./entities/orderSoftware"), exports);
+__exportStar(require("./entities/dataListOrderSoftware"), exports);
+__exportStar(require("./orderSoftwareClient"), exports);
+//# sourceMappingURL=index.js.map

package/build/orderSoftware/orderSoftwareClient.d.ts

@@ -0,0 +1,11 @@
+import { AbstractRestfulClient } from '../abstractRestfulClient';
+import { GetResult } from '../getResult';
+import { DataListOrdersSoftware } from './entities/dataListOrderSoftware';
+export declare class OrderSoftwareClient extends AbstractRestfulClient {
+    /**
+     * The base path of the API
+     */
+    protected basePath: string;
+    getOrdersList(dateBegin?: string): Promise<GetResult<DataListOrdersSoftware>>;
+    getOrder(orderReference: string): Promise<GetResult<DataListOrdersSoftware>>;
+}

package/build/orderSoftware/orderSoftwareClient.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSoftwareClient = void 0;
+const abstractRestfulClient_1 = require("../abstractRestfulClient");
+const getResult_1 = require("../getResult");
+const dataListOrderSoftware_1 = require("./entities/dataListOrderSoftware");
+class OrderSoftwareClient extends abstractRestfulClient_1.AbstractRestfulClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * The base path of the API
+         */
+        this.basePath = '/orderSoftware';
+    }
+    async getOrdersList(dateBegin) {
+        this.path = '/';
+        return new getResult_1.GetResult(dataListOrderSoftware_1.DataListOrdersSoftware, await this.get(dateBegin ? { dateBegin } : {}));
+    }
+    async getOrder(orderReference) {
+        this.path = `/${orderReference}`;
+        return new getResult_1.GetResult(dataListOrderSoftware_1.DataListOrdersSoftware, await this.get());
+    }
+}
+exports.OrderSoftwareClient = OrderSoftwareClient;
+//# sourceMappingURL=orderSoftwareClient.js.map

package/build/publicApiClient.d.ts

@@ -18,6 +18,9 @@ import { PartnerClient } from './partner';
 import { OrganizationUnitClient } from './organisationUnit';
 import { QuotesClient } from './quotes';
 import { BillingClient } from './billing';
+import { AnalyticsClient } from './analytics';
+import { ReportsClient } from './reports';
+import { OrderSoftwareClient } from './orderSoftware';
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -69,6 +72,11 @@ export declare class PublicApiClient extends AbstractRestfulClient {
      * @returns {@link OrdersClient}
      */
     getOrdersClient(configuration?: ConfigurationsClient): OrdersClient;
+    /**
+     * Creates a new {@link OrderSoftwareClient} instance and returns it
+     * @returns {@link OrderSoftwareClient}
+     */
+    getOrderSoftwareClient(configuration?: ConfigurationsClient): OrderSoftwareClient;
     /**
      * Creates a new {@link ContactClient} instance and returns it
      * @returns {@link ContactClient}
@@ -99,5 +107,7 @@ export declare class PublicApiClient extends AbstractRestfulClient {
     getNotificationsClient(configuration?: ConfigurationsClient): NotificationsClient;
     getOrganizationUnitClient(configuration?: ConfigurationsClient): OrganizationUnitClient;
     getBillingClient(configuration?: ConfigurationsClient): BillingClient;
+    getAnalyticsClient(configuration?: ConfigurationsClient): AnalyticsClient;
+    getReportsClient(configuration?: ConfigurationsClient): ReportsClient;
 }
 export default PublicApiClient;

package/build/publicApiClient.js

@@ -21,6 +21,9 @@ const partner_1 = require("./partner");
 const organisationUnit_1 = require("./organisationUnit");
 const quotes_1 = require("./quotes");
 const billing_1 = require("./billing");
+const analytics_1 = require("./analytics");
+const reports_1 = require("./reports");
+const orderSoftware_1 = require("./orderSoftware");
 /**
  * Public API Client class, should be the main entry point for your calls
  */
@@ -117,6 +120,15 @@ class PublicApiClient extends abstractRestfulClient_1.AbstractRestfulClient {
         this.applyConfig(client);
         return client;
     }
+    /**
+     * Creates a new {@link OrderSoftwareClient} instance and returns it
+     * @returns {@link OrderSoftwareClient}
+     */
+    getOrderSoftwareClient(configuration) {
+        const client = new orderSoftware_1.OrderSoftwareClient(configuration);
+        this.applyConfig(client);
+        return client;
+    }
     /**
      * Creates a new {@link ContactClient} instance and returns it
      * @returns {@link ContactClient}
@@ -203,6 +215,16 @@ class PublicApiClient extends abstractRestfulClient_1.AbstractRestfulClient {
         this.applyConfig(client);
         return client;
     }
+    getAnalyticsClient(configuration) {
+        const client = new analytics_1.AnalyticsClient(configuration);
+        this.applyConfig(client);
+        return client;
+    }
+    getReportsClient(configuration) {
+        const client = new reports_1.ReportsClient(configuration);
+        this.applyConfig(client);
+        return client;
+    }
 }
 exports.PublicApiClient = PublicApiClient;
 exports.default = PublicApiClient;

package/build/reports/entities/dataListReports.d.ts

@@ -0,0 +1,14 @@
+import { AbstractEntity } from '../../abstractEntity';
+import { Report, ReportType } from './report';
+export declare enum DataListReportsFields {
+    COLUMN_REPORTS = "reports"
+}
+export declare type DataListReportsType = {
+    [DataListReportsFields.COLUMN_REPORTS]: Array<ReportType>;
+};
+export declare class DataListReports extends AbstractEntity<DataListReportsType> {
+    #private;
+    constructor(listReportDataInput: DataListReportsType);
+    get reports(): Array<Report>;
+    toJSON(): DataListReportsType;
+}

package/build/reports/entities/dataListReports.js

@@ -0,0 +1,39 @@
+"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 _DataListReports_reports;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataListReports = exports.DataListReportsFields = void 0;
+const abstractEntity_1 = require("../../abstractEntity");
+const report_1 = require("./report");
+var DataListReportsFields;
+(function (DataListReportsFields) {
+    DataListReportsFields["COLUMN_REPORTS"] = "reports";
+})(DataListReportsFields = exports.DataListReportsFields || (exports.DataListReportsFields = {}));
+class DataListReports extends abstractEntity_1.AbstractEntity {
+    constructor(listReportDataInput) {
+        super(listReportDataInput);
+        _DataListReports_reports.set(this, void 0);
+        __classPrivateFieldSet(this, _DataListReports_reports, listReportDataInput[DataListReportsFields.COLUMN_REPORTS].map((report) => new report_1.Report(report)), "f");
+    }
+    get reports() {
+        return __classPrivateFieldGet(this, _DataListReports_reports, "f");
+    }
+    toJSON() {
+        return {
+            [DataListReportsFields.COLUMN_REPORTS]: this.reports.map((report) => report.toJSON()),
+        };
+    }
+}
+exports.DataListReports = DataListReports;
+_DataListReports_reports = new WeakMap();
+//# sourceMappingURL=dataListReports.js.map

package/build/reports/entities/reference.d.ts

@@ -0,0 +1,12 @@
+export declare enum ReferenceFields {
+    COLUMN_REFERENCE = "reference"
+}
+export declare type ReferenceType = {
+    [ReferenceFields.COLUMN_REFERENCE]: string;
+};
+export declare class Reference {
+    #private;
+    constructor(reference: ReferenceType);
+    get reference(): string;
+    toJSON(): ReferenceType;
+}

package/build/reports/entities/reference.js

@@ -0,0 +1,36 @@
+"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 _Reference_reference;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reference = exports.ReferenceFields = void 0;
+var ReferenceFields;
+(function (ReferenceFields) {
+    ReferenceFields["COLUMN_REFERENCE"] = "reference";
+})(ReferenceFields = exports.ReferenceFields || (exports.ReferenceFields = {}));
+class Reference {
+    constructor(reference) {
+        _Reference_reference.set(this, void 0);
+        __classPrivateFieldSet(this, _Reference_reference, reference[ReferenceFields.COLUMN_REFERENCE], "f");
+    }
+    get reference() {
+        return __classPrivateFieldGet(this, _Reference_reference, "f");
+    }
+    toJSON() {
+        return {
+            [ReferenceFields.COLUMN_REFERENCE]: this.reference,
+        };
+    }
+}
+exports.Reference = Reference;
+_Reference_reference = new WeakMap();
+//# sourceMappingURL=reference.js.map